Merge pull request #52 from CppCXY/master

code reformat

Author: sumneko

client/out/ConfigWatcher.js

@@ -0,0 +1,93 @@
+import path = require('path');
+import * as vscode from 'vscode';
+
+export enum UpdateType {
+    Created = 1,
+    Changed = 2,
+    Deleted = 3
+}
+
+export interface IConfigSource {
+    uri: string;
+    path: string;
+    workspace: string;
+}
+
+export interface IConfigUpdate {
+    type: UpdateType;
+    source: IConfigSource;
+}
+
+export class ConfigWatcher implements vscode.Disposable {
+    private watcher?: vscode.FileSystemWatcher;
+    private emitter = new vscode.EventEmitter<IConfigUpdate>();
+    private configFiles: IConfigSource[] = [];
+
+    constructor(private pattern: string) {
+        
+    }
+
+
+    get onConfigUpdate(): vscode.Event<IConfigUpdate> {
+        return this.emitter.event;
+    }
+
+    async watch() {
+        const files = await vscode.workspace.findFiles(this.pattern);
+        const configFiles: IConfigSource[] = [];
+        for (let i = 0; i < files.length; i++) {
+            const fileUri = files[i];
+            const ws = path.dirname(fileUri.toString());
+            if (ws) {
+                configFiles.push({
+                    workspace: ws,
+                    uri: fileUri.toString(),
+                    path: fileUri.fsPath
+                });
+            }
+        }
+
+        this.watcher = vscode.workspace.createFileSystemWatcher(this.pattern);
+        this.watcher.onDidCreate(uri => this.updateConfig(UpdateType.Created, uri));
+        this.watcher.onDidChange(uri => this.updateConfig(UpdateType.Changed, uri));
+        this.watcher.onDidDelete(uri => this.updateConfig(UpdateType.Deleted, uri));
+
+        this.configFiles = configFiles;
+        return configFiles;
+    }
+
+    private findConfig(uri: vscode.Uri): IConfigSource | undefined {
+        return this.configFiles.find(it => it.uri === uri.toString());
+    }
+
+    private async updateConfig(type: UpdateType, uri: vscode.Uri) {
+        let config = this.findConfig(uri);
+        if (config) {
+            if (type === UpdateType.Deleted) {
+                const index = this.configFiles.indexOf(config);
+                this.configFiles.splice(index, 1);
+            }
+        }
+        else {
+            const ws = await vscode.workspace.getWorkspaceFolder(uri);
+            if (!ws) {
+                return;
+            }
+            config = {
+                workspace: ws.uri.toString(),
+                uri: uri.toString(),
+                path: uri.fsPath
+            };
+            this.configFiles.push(config);
+            type = UpdateType.Created;
+        }
+        this.emitter.fire({ type: type, source: config });
+    }
+
+    dispose() {
+        if (this.watcher) {
+            this.watcher.dispose();
+            this.watcher = undefined;
+        }
+    }
+}

client/out/languageserver.js

@@ -21,8 +21,11 @@ import {
     ServerOptions,
     DocumentSelector,
 } from 'vscode-languageclient/node';
+import { ConfigWatcher, IConfigUpdate } from "./ConfigWatcher";
+
 
 let defaultClient: LuaClient;
+let editorConfigWatcher: ConfigWatcher;
 
 type HintResult = {
     text: string,
@@ -57,6 +60,17 @@ function registerCustomCommands(context: ExtensionContext) {
     }))
 }
 
+function registerConfigWatch(context: ExtensionContext) {
+    editorConfigWatcher = new ConfigWatcher('**/.editorconfig');
+
+    editorConfigWatcher.onConfigUpdate(onEditorConfigUpdate);
+    context.subscriptions.push(editorConfigWatcher);
+}
+
+function onEditorConfigUpdate(e: IConfigUpdate) {
+    defaultClient?.client?.sendRequest('config/editorconfig/update', e);
+}
+
 let _sortedWorkspaceFolders: string[] | undefined;
 function sortedWorkspaceFolders(): string[] {
     if (_sortedWorkspaceFolders === void 0) {
@@ -91,17 +105,15 @@ function getOuterMostWorkspaceFolder(folder: WorkspaceFolder): WorkspaceFolder {
 }
 
 class LuaClient {
-    private context: ExtensionContext;
-    private documentSelector: DocumentSelector;
-    protected client: LanguageClient;
-    private disposables: Disposable[];
-    constructor(context: ExtensionContext, documentSelector: DocumentSelector) {
-        this.context = context;
-        this.documentSelector = documentSelector;
-        this.disposables = new Array<Disposable>();
+
+    public client: LanguageClient;
+    private disposables = new Array<Disposable>();
+    constructor(private context: ExtensionContext,
+                private documentSelector: DocumentSelector) {
     }
 
     async start() {
+        const editorConfigFiles = await editorConfigWatcher.watch();
         // Options to control the language client
         let clientOptions: LanguageClientOptions = {
             // Register the server for plain text documents
@@ -112,6 +124,7 @@ class LuaClient {
             },
             initializationOptions: {
                 changeConfiguration: true,
+                editorConfigFiles
             }
         };
 
@@ -342,6 +355,7 @@ function onInlayHint(client: LanguageClient) {
 
 export function activate(context: ExtensionContext) {
     registerCustomCommands(context);
+    registerConfigWatch(context);
     function didOpenTextDocument(document: TextDocument) {
         // We are only interested in language mode text
         if (document.languageId !== 'lua' || (document.uri.scheme !== 'file' && document.uri.scheme !== 'untitled')) {