Make tab width 2 spaces (#445)

arduino-ide-extension/src/browser/theia/monaco/monaco-editor-provider.ts

@@ -1,101 +1,97 @@
 import { inject, injectable } from 'inversify';
 import URI from '@theia/core/lib/common/uri';
 import {
-    Disposable,
-    DisposableCollection,
+  Disposable,
+  DisposableCollection,
 } from '@theia/core/lib/common/disposable';
 import { MonacoEditor } from '@theia/monaco/lib/browser/monaco-editor';
 import { MonacoEditorProvider as TheiaMonacoEditorProvider } from '@theia/monaco/lib/browser/monaco-editor-provider';
 import { SketchesServiceClientImpl } from '../../../common/protocol/sketches-service-client-impl';
 
 type CancelablePromise = Promise<monaco.referenceSearch.ReferencesModel> & {
-    cancel: () => void;
+  cancel: () => void;
 };
 interface EditorFactory {
-    (
-        override: monaco.editor.IEditorOverrideServices,
-        toDispose: DisposableCollection
-    ): Promise<MonacoEditor>;
+  (
+    override: monaco.editor.IEditorOverrideServices,
+    toDispose: DisposableCollection
+  ): Promise<MonacoEditor>;
 }
 
 @injectable()
 export class MonacoEditorProvider extends TheiaMonacoEditorProvider {
-    @inject(SketchesServiceClientImpl)
-    protected readonly sketchesServiceClient: SketchesServiceClientImpl;
+  @inject(SketchesServiceClientImpl)
+  protected readonly sketchesServiceClient: SketchesServiceClientImpl;
 
-    protected async doCreateEditor(
-        uri: URI,
-        factory: EditorFactory
-    ): Promise<MonacoEditor> {
-        const editor = await super.doCreateEditor(uri, factory);
-        const toDispose = new DisposableCollection();
-        toDispose.push(this.installCustomReferencesController(editor));
-        toDispose.push(editor.onDispose(() => toDispose.dispose()));
-        return editor;
-    }
+  protected async doCreateEditor(
+    uri: URI,
+    factory: EditorFactory
+  ): Promise<MonacoEditor> {
+    const editor = await super.doCreateEditor(uri, factory);
+    const toDispose = new DisposableCollection();
+    toDispose.push(this.installCustomReferencesController(editor));
+    toDispose.push(editor.onDispose(() => toDispose.dispose()));
+    return editor;
+  }
 
-    private installCustomReferencesController(
-        editor: MonacoEditor
-    ): Disposable {
-        const control = editor.getControl();
-        const referencesController =
-            control._contributions['editor.contrib.referencesController'];
-        const originalToggleWidget = referencesController.toggleWidget;
-        const toDispose = new DisposableCollection();
-        const toDisposeBeforeToggleWidget = new DisposableCollection();
-        referencesController.toggleWidget = (
-            range: monaco.Range,
-            modelPromise: CancelablePromise,
-            peekMode: boolean
-        ) => {
-            toDisposeBeforeToggleWidget.dispose();
-            originalToggleWidget.bind(referencesController)(
-                range,
-                modelPromise,
-                peekMode
-            );
-            if (referencesController._widget) {
-                if ('onDidClose' in referencesController._widget) {
-                    toDisposeBeforeToggleWidget.push(
-                        (referencesController._widget as any).onDidClose(() =>
-                            toDisposeBeforeToggleWidget.dispose()
-                        )
-                    );
-                }
-                const preview = (referencesController._widget as any)
-                    ._preview as monaco.editor.ICodeEditor;
-                if (preview) {
-                    toDisposeBeforeToggleWidget.push(
-                        preview.onDidChangeModel(() =>
-                            this.updateReadOnlyState(preview)
-                        )
-                    );
-                    this.updateReadOnlyState(preview);
-                }
-            }
-        };
-        toDispose.push(
-            Disposable.create(() => toDisposeBeforeToggleWidget.dispose())
-        );
-        toDispose.push(
-            Disposable.create(
-                () => (referencesController.toggleWidget = originalToggleWidget)
+  private installCustomReferencesController(editor: MonacoEditor): Disposable {
+    const control = editor.getControl();
+    const referencesController =
+      control._contributions['editor.contrib.referencesController'];
+    const originalToggleWidget = referencesController.toggleWidget;
+    const toDispose = new DisposableCollection();
+    const toDisposeBeforeToggleWidget = new DisposableCollection();
+    referencesController.toggleWidget = (
+      range: monaco.Range,
+      modelPromise: CancelablePromise,
+      peekMode: boolean
+    ) => {
+      toDisposeBeforeToggleWidget.dispose();
+      originalToggleWidget.bind(referencesController)(
+        range,
+        modelPromise,
+        peekMode
+      );
+      if (referencesController._widget) {
+        if ('onDidClose' in referencesController._widget) {
+          toDisposeBeforeToggleWidget.push(
+            (referencesController._widget as any).onDidClose(() =>
+              toDisposeBeforeToggleWidget.dispose()
             )
-        );
-        return toDispose;
-    }
+          );
+        }
+        const preview = (referencesController._widget as any)
+          ._preview as monaco.editor.ICodeEditor;
+        if (preview) {
+          toDisposeBeforeToggleWidget.push(
+            preview.onDidChangeModel(() => this.updateReadOnlyState(preview))
+          );
+          this.updateReadOnlyState(preview);
+        }
+      }
+    };
+    toDispose.push(
+      Disposable.create(() => toDisposeBeforeToggleWidget.dispose())
+    );
+    toDispose.push(
+      Disposable.create(
+        () => (referencesController.toggleWidget = originalToggleWidget)
+      )
+    );
+    return toDispose;
+  }
 
-    private updateReadOnlyState(
-        editor: monaco.editor.ICodeEditor | undefined
-    ): void {
-        if (!editor) {
-            return;
-        }
-        const model = editor.getModel();
-        if (!model) {
-            return;
-        }
-        const readOnly = this.sketchesServiceClient.isReadOnly(model.uri);
-        editor.updateOptions({ readOnly });
+  private updateReadOnlyState(
+    editor: monaco.editor.ICodeEditor | undefined
+  ): void {
+    if (!editor) {
+      return;
     }
+    const model = editor.getModel();
+    if (!model) {
+      return;
+    }
+    const readOnly = this.sketchesServiceClient.isReadOnly(model.uri);
+    editor.updateOptions({ readOnly });
+  }
 }

arduino-ide-extension/src/browser/theia/monaco/monaco-status-bar-contribution.ts

@@ -3,7 +3,7 @@ import { MonacoStatusBarContribution as TheiaMonacoStatusBarContribution } from
 
 @injectable()
 export class MonacoStatusBarContribution extends TheiaMonacoStatusBarContribution {
-    protected setConfigTabSizeWidget() {}
+  protected setConfigTabSizeWidget() {}
 
-    protected setLineEndingWidget() {}
+  protected setLineEndingWidget() {}
 }

arduino-ide-extension/src/browser/theia/monaco/monaco-text-model-service.ts

@@ -10,73 +10,71 @@ import { SketchesServiceClientImpl } from '../../../common/protocol/sketches-ser
 
 @injectable()
 export class MonacoTextModelService extends TheiaMonacoTextModelService {
-    @inject(SketchesServiceClientImpl)
-    protected readonly sketchesServiceClient: SketchesServiceClientImpl;
+  @inject(SketchesServiceClientImpl)
+  protected readonly sketchesServiceClient: SketchesServiceClientImpl;
 
-    protected async createModel(
-        resource: Resource
-    ): Promise<MonacoEditorModel> {
-        const factory = this.factories
-            .getContributions()
-            .find(({ scheme }) => resource.uri.scheme === scheme);
-        const readOnly = this.sketchesServiceClient.isReadOnly(resource.uri);
-        return factory
-            ? factory.createModel(resource)
-            : new MaybeReadonlyMonacoEditorModel(
-                  resource,
-                  this.m2p,
-                  this.p2m,
-                  this.logger,
-                  undefined,
-                  readOnly
-              );
-    }
+  protected async createModel(resource: Resource): Promise<MonacoEditorModel> {
+    const factory = this.factories
+      .getContributions()
+      .find(({ scheme }) => resource.uri.scheme === scheme);
+    const readOnly = this.sketchesServiceClient.isReadOnly(resource.uri);
+    return factory
+      ? factory.createModel(resource)
+      : new MaybeReadonlyMonacoEditorModel(
+          resource,
+          this.m2p,
+          this.p2m,
+          this.logger,
+          undefined,
+          readOnly
+        );
+  }
 }
 
 // https://github.com/eclipse-theia/theia/pull/8491
 class SilentMonacoEditorModel extends MonacoEditorModel {
-    protected trace(loggable: Loggable): void {
-        if (this.logger) {
-            this.logger.trace((log: Log) =>
-                loggable((message, ...params) =>
-                    log(message, ...params, this.resource.uri.toString(true))
-                )
-            );
-        }
+  protected trace(loggable: Loggable): void {
+    if (this.logger) {
+      this.logger.trace((log: Log) =>
+        loggable((message, ...params) =>
+          log(message, ...params, this.resource.uri.toString(true))
+        )
+      );
     }
+  }
 }
 
 class MaybeReadonlyMonacoEditorModel extends SilentMonacoEditorModel {
-    constructor(
-        protected readonly resource: Resource,
-        protected readonly m2p: MonacoToProtocolConverter,
-        protected readonly p2m: ProtocolToMonacoConverter,
-        protected readonly logger?: ILogger,
-        protected readonly editorPreferences?: EditorPreferences,
-        protected readonly _readOnly?: boolean
-    ) {
-        super(resource, m2p, p2m, logger, editorPreferences);
-    }
+  constructor(
+    protected readonly resource: Resource,
+    protected readonly m2p: MonacoToProtocolConverter,
+    protected readonly p2m: ProtocolToMonacoConverter,
+    protected readonly logger?: ILogger,
+    protected readonly editorPreferences?: EditorPreferences,
+    protected readonly _readOnly?: boolean
+  ) {
+    super(resource, m2p, p2m, logger, editorPreferences);
+  }
 
-    get readOnly(): boolean {
-        if (typeof this._readOnly === 'boolean') {
-            return this._readOnly;
-        }
-        return this.resource.saveContents === undefined;
+  get readOnly(): boolean {
+    if (typeof this._readOnly === 'boolean') {
+      return this._readOnly;
     }
+    return this.resource.saveContents === undefined;
+  }
 
-    protected setDirty(dirty: boolean): void {
-        if (this._readOnly === true) {
-            // NOOP
-            return;
-        }
-        if (dirty === this._dirty) {
-            return;
-        }
-        this._dirty = dirty;
-        if (dirty === false) {
-            (this as any).updateSavedVersionId();
-        }
-        this.onDirtyChangedEmitter.fire(undefined);
+  protected setDirty(dirty: boolean): void {
+    if (this._readOnly === true) {
+      // NOOP
+      return;
     }
+    if (dirty === this._dirty) {
+      return;
+    }
+    this._dirty = dirty;
+    if (dirty === false) {
+      (this as any).updateSavedVersionId();
+    }
+    this.onDirtyChangedEmitter.fire(undefined);
+  }
 }