Import docdata from godot editor

Better unused variable checking

src/docdata.ts

@@ -0,0 +1,86 @@
+"use strict";
+import * as fs from 'fs';
+import requestGodot from './request';
+import * as vscode from 'vscode';
+import * as path from 'path';
+
+let version: string;
+let storageDir: string;
+let docdata: Object = null;
+
+class DocDataManager {
+
+  constructor(dir: string) {
+    version = "";
+    storageDir = dir;
+    console.log(dir);
+    // Load documents
+    DocDataManager.getDocData().then(doc=>{
+      docdata = doc;
+      console.log("Godot Documentations loaded.");
+      // vscode.window.showInformationMessage("Godot Documentations loaded.");
+    }).catch(e=>{
+      console.log(e);
+    });
+  }
+
+  private static checkversion():Promise<string> {
+    return new Promise((resolve, reject) => {
+      if (version != "")
+        resolve(version)
+      else {
+        requestGodot({action: "editor", command: "version"}).then((res:any)=>{
+          version = res.version;
+          resolve(version);
+        }).catch(e=>{
+          reject(e);
+        });
+      }
+    });
+  }
+
+  public static getDocData() {
+    return new Promise((resolve, reject) => {
+      if(docdata)
+        resolve(docdata);
+      else {
+          DocDataManager.checkversion().then((version: string)=> {
+            try {
+              const dir = path.join(storageDir, "docs");
+              if(!(fs.existsSync(dir)))
+                fs.mkdirSync(dir)
+              // Load docdata from file
+              const loadDocdata = (docfile) => {
+                const content = fs.readFileSync(docfile, "utf-8");
+                if(content && content.length > 0) {
+                  docdata = JSON.parse(content);
+                  resolve(docdata);
+                }
+                else
+                  reject(new Error("Load Docdata failed!"));
+              };
+              const docfile: string = path.join(dir, version+".json")
+              if(fs.existsSync(docfile) && fs.statSync(docfile).isFile())
+                loadDocdata(docfile);
+              else {
+                requestGodot({action: "editor", command: "gendoc", path: docfile}).then((res:any)=>{
+                  if(res && res.done)
+                    loadDocdata(docfile);
+                  else
+                    reject(new Error("Generate Docdata failed!"));
+                }).catch(e=>{
+                  reject(new Error("Generate Docdata failed!"));
+                });
+              }
+            } catch (error) {
+              reject(new Error("Generate Docdata failed!"));
+            }
+          }).catch(e=> {
+            reject(new Error("Get Docdata failed: cannot get version of your godot editor!"));
+        }); 
+      }
+    });
+  }
+}
+
+export default DocDataManager;

src/extension.ts

@@ -1,10 +1,13 @@
 'use strict';
-
 import { workspace, Disposable, ExtensionContext } from 'vscode';
-import * as vscode from "vscode";
 import WindowWatch from "./window_watcher";
+import ToolManager from './tool_manager';
+
+let tool: ToolManager = null;
 
 export function activate(context: ExtensionContext) {
+	tool = new ToolManager(context);
+	context.subscriptions.push(tool);
 	context.subscriptions.push(new WindowWatch());
 	console.log("[GodotTools]: Extension Activated");
 }

src/gdscript/parser.ts

@@ -54,8 +54,11 @@ class GDParser {
     });
     // Unused variables
     const checker = (name:string, line: number) => {
-      if(request.text.indexOf(name) == request.text.lastIndexOf(name))
-        diagnostics.push(new vscode.Diagnostic(new vscode.Range(line-1, 4, line-1, 30), `${name} is never used.`, DiagnosticSeverity.Warning));
+      const lines = request.text.split(/\r?\n/);
+      const pattern = `[\\s\\+\\-\\*/%\\^\\(]${name}[^a-zA-Z_\\$]`;
+      var matchs = request.text.match(new RegExp(pattern, 'gi'));
+      if(matchs.length <= 1)
+        diagnostics.push(new vscode.Diagnostic(new vscode.Range(line-1, lines[line-1].indexOf(name), line-1, lines[line-1].indexOf(name) + name.length), `${name} is never used.`, DiagnosticSeverity.Warning));
     };
     for (let key of Object.keys(script.members.variables))
       checker(key, script.members.variables[key]);

src/request.ts

@@ -15,7 +15,8 @@ function requestGodot(body : Object) {
         body
     };
     let promise = new Promise((resolve, reject) => {
-        var req = http.request(options, (res) => {
+        try {
+            var req = http.request(options, (res) => {
             let resultString = "";
             res.setEncoding('utf8');
             res.on('data', (chunk) => {
@@ -27,9 +28,12 @@ function requestGodot(body : Object) {
             req.on('error', (e) => {
                 reject(e);
             });
-        });
-        req.write(postString);
-        req.end();
+            });
+            req.write(postString);
+            req.end();
+        } catch (error) {
+            reject(error);
+        }
     });
     return promise;
 }

src/tool_manager.ts

@@ -0,0 +1,37 @@
+import * as vscode from 'vscode';
+import DocDataManager from './docdata';
+import godotRequest from './request';
+
+class ToolManager {
+
+  private workspaceDir: string = "";
+  private docs: DocDataManager = null;
+  
+  constructor(context: vscode.ExtensionContext) {
+    this.workspaceDir = vscode.workspace.rootPath;
+    this.validate();
+    this.docs = new DocDataManager(context.extensionPath);
+  }
+
+  validate() {
+    const self = this;
+    godotRequest({action: "editor", command: "projectdir"}).then((res: any)=>{
+      let path = res.path;
+      if(path && path.length> 0 && path.endsWith("/"))
+        path = path.substring(0, path.length-1)
+      if( path == self.workspaceDir)
+        vscode.window.showInformationMessage("Connected to godot editor server");
+      else {
+        vscode.window.showWarningMessage("The opened project is not same with godot editor");
+      }
+    }).catch(e=>{
+        vscode.window.showErrorMessage("Failed connect to godot editor server");
+    });
+  }
+
+  dispose() {
+
+  }
+};
+
+export default ToolManager;

src/window_watcher.ts

@@ -2,8 +2,6 @@ import {Disposable, window} from 'vscode';
 import parse from "./gdscript/parser";
 import GDParser from './gdscript/parser';
 import GDScriptCompleter from './gdscript/completion';
-import * as path from 'path';
-import * as fs from 'fs';
 
 
 interface DocumentFlag {