lanuage configuration, formatter, search on server

Author: daimor

src/api/index.ts

@@ -49,6 +49,10 @@ export class AtelierAPI {
     this.setConnection(workspaceFolderName || currentWorkspaceFolder());
   }
 
+  public get enabled(): boolean {
+    return this.config.active;
+  }
+
   public setNamespace(namespace: string) {
     this.namespace = namespace;
   }
@@ -261,7 +265,7 @@ export class AtelierAPI {
     word?: boolean;
   }): Promise<any> {
     params = {
-      files: "*.cls,*.mac,*.inc",
+      files: "*.cls,*.mac,*.int,*.inc",
       gen: false,
       sys: false,
       regex: false,

src/atelier.d.ts

@@ -0,0 +1,20 @@
+export interface AtelierSearchMatch {
+  text: string;
+  line?: number;
+  member?: string;
+  attr?: string;
+  attrline?: number;
+}
+
+export interface AtelierSearchResult {
+  doc: string;
+  matches: AtelierSearchMatch[];
+}
+
+export interface AtelierJob {
+  pid: number;
+  namespace: string;
+  routine: string;
+  state: string;
+  device: string;
+}

src/debug/dbgp.ts

@@ -102,6 +102,7 @@ export class DbgpConnection extends EventEmitter {
             },
           },
         });
+        console.log(xml);
         const document = parser.parseFromString(xml, "application/xml");
         this.emit("message", document);
         // reset buffer

src/debug/xdebugConnection.ts

@@ -910,6 +910,7 @@ export class Connection extends DbgpConnection {
     const data = iconv.encode(commandString, ENCODING);
     this._pendingCommands.set(transactionId, command);
     this._pendingExecuteCommand = command.isExecuteCommand;
+    console.log(data.toString());
     await this.write(data);
   }
 

src/extension.ts

@@ -1,10 +1,10 @@
 import vscode = require("vscode");
+import { AtelierJob } from "./atelier";
 const { workspace, window } = vscode;
 export const OBJECTSCRIPT_FILE_SCHEMA = "objectscript";
 export const OBJECTSCRIPTXML_FILE_SCHEMA = "objectscriptxml";
 export const FILESYSTEM_SCHEMA = "isfs";
 export const schemas = [OBJECTSCRIPT_FILE_SCHEMA, OBJECTSCRIPTXML_FILE_SCHEMA, FILESYSTEM_SCHEMA];
-import { AtelierJob } from "./models";
 
 import { importAndCompile, importFolder as importFileOrFolder, namespaceCompile } from "./commands/compile";
 import { deleteItem } from "./commands/delete";
@@ -15,6 +15,8 @@ import { superclass } from "./commands/superclass";
 import { viewOthers } from "./commands/viewOthers";
 import { xml2doc } from "./commands/xml2doc";
 
+import { getLanguageConfiguration } from "./languageConfiguration";
+
 import { DocumentContentProvider } from "./providers/DocumentContentProvider";
 import { DocumentFormattingEditProvider } from "./providers/DocumentFormattingEditProvider";
 import { ObjectScriptClassFoldingRangeProvider } from "./providers/ObjectScriptClassFoldingRangeProvider";
@@ -33,8 +35,12 @@ import { ObjectScriptConfigurationProvider } from "./debug/debugConfProvider";
 import { ObjectScriptExplorerProvider } from "./explorer/explorer";
 import { WorkspaceNode } from "./explorer/models/workspaceNode";
 import { FileSystemProvider } from "./providers/FileSystemPovider/FileSystemProvider";
+import { FileSearchProvider } from "./providers/FileSystemPovider/FileSearchProvider";
+import { TextSearchProvider } from "./providers/FileSystemPovider/TextSearchProvider";
 import { WorkspaceSymbolProvider } from "./providers/WorkspaceSymbolProvider";
 import { currentWorkspaceFolder, outputChannel } from "./utils";
+import { ObjectScriptDiagnosticProvider } from "./providers/ObjectScriptDiagnosticProvider";
+import { DocumentRangeFormattingEditProvider } from "./providers/DocumentRangeFormattingEditProvider";
 export let fileSystemProvider: FileSystemProvider;
 export let explorerProvider: ObjectScriptExplorerProvider;
 export let documentContentProvider: DocumentContentProvider;
@@ -143,13 +149,22 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     }
   });
 
-  const wordPattern = /("(?:[^"]|"")*")|((\${1,3}|[irm]?%|\^|#)?[^`~!@@#%^&*()-=+[{\]}|;:'",.<>/?_\s]+)/;
-
   const documentSelector = (...list) =>
     ["file", ...schemas].reduce((acc, scheme) => acc.concat(list.map(language => ({ scheme, language }))), []);
 
+  const diagnosticProvider = new ObjectScriptDiagnosticProvider();
+  if (vscode.window.activeTextEditor) {
+    diagnosticProvider.updateDiagnostics(vscode.window.activeTextEditor.document);
+  }
+
   context.subscriptions.push(
-    window.onDidChangeActiveTextEditor(e => {
+    workspace.onDidChangeTextDocument(event => {
+      diagnosticProvider.updateDiagnostics(event.document);
+    }),
+    window.onDidChangeActiveTextEditor(editor => {
+      if (editor) {
+        diagnosticProvider.updateDiagnostics(editor.document);
+      }
       if (workspace.workspaceFolders && workspace.workspaceFolders.length > 1) {
         const workspaceFolder = currentWorkspaceFolder();
         if (workspaceFolder && workspaceFolder !== workspaceState.get<string>("workspaceFolder")) {
@@ -220,15 +235,9 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
     vscode.workspace.registerTextDocumentContentProvider(OBJECTSCRIPT_FILE_SCHEMA, documentContentProvider),
     vscode.workspace.registerTextDocumentContentProvider(OBJECTSCRIPTXML_FILE_SCHEMA, xmlContentProvider),
     vscode.workspace.registerFileSystemProvider(FILESYSTEM_SCHEMA, fileSystemProvider, { isCaseSensitive: true }),
-    vscode.languages.setLanguageConfiguration("objectscript-class", {
-      wordPattern,
-    }),
-    vscode.languages.setLanguageConfiguration("objectscript", {
-      wordPattern,
-    }),
-    vscode.languages.setLanguageConfiguration("objectscript-macros", {
-      wordPattern,
-    }),
+    vscode.languages.setLanguageConfiguration("objectscript-class", getLanguageConfiguration()),
+    vscode.languages.setLanguageConfiguration("objectscript", getLanguageConfiguration()),
+    vscode.languages.setLanguageConfiguration("objectscript-macros", getLanguageConfiguration()),
     vscode.languages.registerDocumentSymbolProvider(
       documentSelector("objectscript-class"),
       new ObjectScriptClassSymbolProvider()
@@ -265,9 +274,17 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
       documentSelector("objectscript-class", "objectscript", "objectscript-macros"),
       new DocumentFormattingEditProvider()
     ),
+    vscode.languages.registerDocumentRangeFormattingEditProvider(
+      documentSelector("objectscript-class", "objectscript", "objectscript-macros"),
+      new DocumentRangeFormattingEditProvider()
+    ),
     vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider()),
     vscode.debug.registerDebugConfigurationProvider("objectscript", new ObjectScriptConfigurationProvider()),
     vscode.debug.registerDebugAdapterDescriptorFactory("objectscript", debugAdapterFactory),
-    debugAdapterFactory
+    debugAdapterFactory,
+
+    /* from proposed api */
+    vscode.workspace.registerFileSearchProvider(FILESYSTEM_SCHEMA, new FileSearchProvider()),
+    vscode.workspace.registerTextSearchProvider(FILESYSTEM_SCHEMA, new TextSearchProvider())
   );
 }

src/languageConfiguration.ts

@@ -0,0 +1,21 @@
+import { IndentAction, LanguageConfiguration } from "vscode";
+
+export const WORD_PATTERN = /((?<=(class|extends|as|of) )(%?\b[a-z0-9]+(\.[a-z0-9]+)*\b))|(\^[a-z0-9]+(\.[a-z0-9]+)*)|((\${1,3}|[irm]?%|\^|#)?[a-z0-9]+)/i;
+
+export function getLanguageConfiguration(): LanguageConfiguration {
+  return {
+    wordPattern: WORD_PATTERN,
+    brackets: [["{", "}"], ["(", ")"], ['"', '"']],
+    comments: {
+      lineComment: "#;",
+      blockComment: ["/*", "*/"],
+    },
+    onEnterRules: [
+      {
+        beforeText: /^\/\/\//,
+        afterText: /.*/,
+        action: { indentAction: IndentAction.None, appendText: "/// " },
+      },
+    ],
+  };
+}

src/models.ts

@@ -1,30 +1,174 @@
 import * as vscode from "vscode";
-
+import { Formatter } from "./Formatter";
 import commands = require("./completion/commands.json");
+import systemFunctions = require("./completion/systemFunctions.json");
+import systemVariables = require("./completion/systemVariables.json");
 
 export class DocumentFormattingEditProvider implements vscode.DocumentFormattingEditProvider {
+  private _formatter: Formatter;
+  public constructor() {
+    this._formatter = new Formatter();
+  }
+
   public provideDocumentFormattingEdits(
     document: vscode.TextDocument,
     options: vscode.FormattingOptions,
     token: vscode.CancellationToken
   ): vscode.ProviderResult<vscode.TextEdit[]> {
+    return [...this.commands(document, options), ...this.functions(document, options)];
+  }
+
+  private commands(document: vscode.TextDocument, options: vscode.FormattingOptions): vscode.TextEdit[] {
     const edits = [];
+    let indent = 1;
 
     for (let i = 0; i < document.lineCount; i++) {
       const line = document.lineAt(i);
 
-      const commandsMatch = line.text.match(/^\s+(?:}\s)?\b([a-z]+)\b/i);
+      if (line.text.length && !line.text.trim().length) {
+        edits.push({
+          newText: "",
+          range: line.range,
+        });
+        continue;
+      }
+
+      const commentsMatch = line.text.match(/^(\s*)(\/\/+|#+;\s*|;)(.*)/i);
+      if (commentsMatch) {
+        const indentSize = options.tabSize * indent;
+        const [, space, comment] = commentsMatch;
+        let newText;
+        if (space === "" && comment.match(/\/{3}/)) {
+          newText = "";
+        } else {
+          newText = " ".repeat(indentSize);
+        }
+
+        if (options.insertSpaces && space.length !== newText.length) {
+          edits.push({
+            newText,
+            range: new vscode.Range(new vscode.Position(i, 0), new vscode.Position(i, space.length)),
+          });
+        }
+        continue;
+      }
+
+      const dotsMatch = line.text.match(/^\s+(\.\s*)+/);
+      if (dotsMatch) {
+        const indentSize = options.tabSize;
+        const [dots] = dotsMatch;
+        const newText =
+          " ".repeat(indentSize) +
+          dots
+            .split(".")
+            .slice(1)
+            .map(() => "." + " ".repeat(indentSize - 1))
+            .join("");
+        if (options.insertSpaces && dots.length !== newText.length) {
+          edits.push({
+            newText,
+            range: new vscode.Range(new vscode.Position(i, 0), new vscode.Position(i, dots.length)),
+          });
+        }
+      }
+
+      const bracketMatch = line.text.match(/^(\s+)}(.*)$/);
+      if (bracketMatch) {
+        indent--;
+        const indentSize = options.tabSize * indent;
+        const [, space, rest] = bracketMatch;
+        if (options.insertSpaces && space.length !== indentSize) {
+          edits.push({
+            newText: " ".repeat(indentSize),
+            range: new vscode.Range(new vscode.Position(i, 0), new vscode.Position(i, space.length)),
+          });
+        }
+        if (rest.trimLeft().length) {
+          const pos = line.text.indexOf("}") + 1;
+          edits.push({
+            newText: "\n" + " ".repeat(indentSize),
+            range: new vscode.Range(
+              new vscode.Position(i, pos),
+              new vscode.Position(i, pos + rest.length - rest.trimLeft().length)
+            ),
+          });
+        }
+      }
+
+      const commandsMatch = line.text.match(/^(\s+[\s.]*)\b([a-z]+)\b/i);
       if (commandsMatch) {
-        const [, found] = commandsMatch;
-        const pos = line.text.indexOf(found);
-        const command = commands.find(el => el.alias.includes(found.toUpperCase()));
-        if (command.label !== found) {
-          const range = new vscode.Range(new vscode.Position(i, pos), new vscode.Position(i, pos + found.length));
+        const indentSize = options.tabSize * indent;
+        const [, space, found] = commandsMatch;
+        if (!space.includes(".") && options.insertSpaces && space.length !== indentSize) {
+          const newText = " ".repeat(indentSize);
           edits.push({
-            newText: command.label,
-            range,
+            newText,
+            range: new vscode.Range(new vscode.Position(i, 0), new vscode.Position(i, space.length)),
           });
         }
+        const pos = line.text.indexOf(found);
+        const range = new vscode.Range(new vscode.Position(i, pos), new vscode.Position(i, pos + found.length));
+        const command = commands.find(el => el.alias.includes(found.toUpperCase()));
+        if (command) {
+          const expect = this._formatter.command(command.label);
+          if (expect !== found) {
+            edits.push({
+              newText: expect,
+              range,
+            });
+          }
+        }
+        const setAssignMatch = line.text.match(
+          /^\s+(?:\.\s*)*set\s(?:\^?%?(?:[a-z][a-z0-9]*)(?:\.[a-z][a-z0-9]*)*)(\s*=\s*)/i
+        );
+        if (setAssignMatch) {
+          const [full, assign] = setAssignMatch;
+          const pos = full.length - assign.length;
+          const newText = " = ";
+          const range = new vscode.Range(new vscode.Position(i, pos), new vscode.Position(i, pos + assign.length));
+          if (assign !== newText) {
+            edits.push({
+              newText,
+              range,
+            });
+          }
+        }
+      }
+
+      if (line.text.match(/^(\w+|{)/)) {
+        indent = 1;
+      } else if (line.text.match(/.+{(?!.*})/)) {
+        indent++;
+      }
+    }
+
+    return edits;
+  }
+
+  private functions(document: vscode.TextDocument, options: vscode.FormattingOptions): vscode.TextEdit[] {
+    const edits = [];
+
+    for (let i = 0; i < document.lineCount; i++) {
+      const line = document.lineAt(i);
+
+      const pattern = /(?<!\$)(\$\b[a-z]+)\b/gi;
+      let functionsMatch = null;
+      while ((functionsMatch = pattern.exec(line.text)) !== null) {
+        const [, found] = functionsMatch;
+        const pos = functionsMatch.index;
+        const range = new vscode.Range(new vscode.Position(i, pos), new vscode.Position(i, pos + found.length));
+        const systemFunction = [...systemFunctions, ...systemVariables].find(el =>
+          el.alias.includes(found.toUpperCase())
+        );
+        if (systemFunction) {
+          const expect = this._formatter.function(systemFunction.label);
+          if (expect !== found) {
+            edits.push({
+              newText: expect,
+              range,
+            });
+          }
+        }
       }
     }
 

src/providers/DocumentFormattingEditProvider.ts

@@ -0,0 +1,12 @@
+import * as vscode from "vscode";
+
+export class DocumentRangeFormattingEditProvider implements vscode.DocumentRangeFormattingEditProvider {
+  public provideDocumentRangeFormattingEdits(
+    document: vscode.TextDocument,
+    range: vscode.Range,
+    options: vscode.FormattingOptions,
+    token: vscode.CancellationToken
+  ): vscode.ProviderResult<vscode.TextEdit[]> {
+    return null;
+  }
+}