go to macros definition

Author: daimor

Diff for: api/index.ts

@@ -37,7 +37,7 @@ export class AtelierAPI {
     this._config = conn;
   }
 
-  request(method: string, path?: string, params?: any, headers?: any, body?: any): Promise<any> {
+  async request(method: string, path?: string, body?: any, params?: any, headers?: any): Promise<any> {
     if (!this._config.active) {
       return Promise.reject();
     }
@@ -146,7 +146,7 @@ export class AtelierAPI {
     type?: string;
     filter?: string;
   }): Promise<any> {
-    return this.request('GET', `v3/${this.ns}/docnames/${category}/${type}`, {
+    return this.request('GET', `v3/${this.ns}/docnames/${category}/${type}`, null, {
       filter,
       generated
     });
@@ -164,35 +164,45 @@ export class AtelierAPI {
 
   putDoc(name: string, data: { enc: boolean; content: string[] }, ignoreConflict?: boolean): Promise<any> {
     let params = { ignoreConflict };
-    return this.request('PUT', `v3/${this.ns}/doc/${name}`, params, {}, data);
+    return this.request('PUT', `v3/${this.ns}/doc/${name}`, data, params);
   }
 
   actionIndex(docs: string[]): Promise<any> {
-    return this.request('POST', `v3/${this.ns}/action/index`, {}, {}, docs);
+    return this.request('POST', `v3/${this.ns}/action/index`, docs);
   }
 
   actionSearch(params: { query: string; files?: string; sys?: boolean; gen?: boolean; max?: number }): Promise<any> {
-    return this.request('GET', `v3/${this.ns}/action/search`, params, {});
+    return this.request('GET', `v3/${this.ns}/action/search`, null, params);
   }
 
   actionQuery(query: string, parameters: string[]): Promise<any> {
-    return this.request(
-      'POST',
-      `v3/${this.ns}/action/query`,
-      {},
-      {},
-      {
-        query,
-        parameters
-      }
-    );
+    return this.request('POST', `v3/${this.ns}/action/query`, {
+      query,
+      parameters
+    });
   }
 
   actionCompile(docs: string[], flags?: string, source = false): Promise<any> {
-    return this.request('POST', `v3/${this.ns}/action/compile`, { flags, source }, {}, docs);
+    return this.request('POST', `v3/${this.ns}/action/compile`, docs, { flags, source });
   }
 
   cvtXmlUdl(source: string): Promise<any> {
-    return this.request('POST', `v3/${this.ns}/cvt/xml/doc`, {}, { 'Content-Type': 'application/xml' }, source);
+    return this.request('POST', `v3/${this.ns}/cvt/xml/doc`, source, {}, { 'Content-Type': 'application/xml' });
+  }
+
+  getmacrodefinition(docname: string, macroname: string, includes: string[]) {
+    return this.request('POST', `v3/${this.ns}/action/getmacrodefinition`, {
+      docname,
+      macroname,
+      includes
+    });
+  }
+
+  getmacrolocation(docname: string, macroname: string, includes: string[]) {
+    return this.request('POST', `v3/${this.ns}/action/getmacrolocation`, {
+      docname,
+      macroname,
+      includes
+    });
   }
 }

Diff for: providers/ObjectScriptDefinitionProvider.ts

@@ -1,5 +1,8 @@
 import * as vscode from 'vscode';
 import { DocumentContentProvider } from './DocumentContentProvider';
+import { AtelierAPI } from '../api';
+import { ClassDefinition } from '../utils/classDefinition';
+import { currentFile } from '../utils';
 
 export class ObjectScriptDefinitionProvider implements vscode.DefinitionProvider {
   provideDefinition(
@@ -9,6 +12,16 @@ export class ObjectScriptDefinitionProvider implements vscode.DefinitionProvider
   ): vscode.ProviderResult<vscode.Location | vscode.Location[] | vscode.DefinitionLink[]> {
     let lineText = document.lineAt(position.line).text;
 
+    let macroRange = document.getWordRangeAtPosition(position, /\${3}\b\w+\b/);
+    let macroText = macroRange ? document.getText(macroRange) : '';
+    let macroMatch = macroText.match(/^\${3}(\b\w+\b)$/);
+    if (macroMatch) {
+      let fileName = currentFile().name;
+      let [, macro] = macroMatch;
+      return this.macro(fileName, macro).then(
+        data => new vscode.Location(DocumentContentProvider.getUri(data.document), new vscode.Position(data.line, 0))
+      );
+    }
     let asClass = /(\b(?:Of|As|Extends)\b %?\b[a-zA-Z][a-zA-Z0-9]+(?:\.[a-zA-Z][a-zA-Z0-9]+)*\b(?! of))/i;
     let parts = lineText.split(asClass);
     let pos = 0;
@@ -149,4 +162,14 @@ export class ObjectScriptDefinitionProvider implements vscode.DefinitionProvider
       targetUri: DocumentContentProvider.getUri(name)
     };
   }
+
+  async macro(fileName: string, macro: string): Promise<{ document: string; line: number }> {
+    const api = new AtelierAPI();
+    let includes = [];
+    if (fileName.toLowerCase().endsWith('cls')) {
+      let classDefinition = new ClassDefinition(fileName);
+      includes = await classDefinition.includeCode();
+    }
+    return api.getmacrolocation(fileName, macro, includes).then(data => data.result.content);
+  }
 }

Diff for: providers/ObjectScriptHoverProvider.ts

@@ -4,6 +4,9 @@ import commands = require('./completion/commands.json');
 import systemFunctions = require('./completion/systemFunctions.json');
 import systemVariables = require('./completion/systemVariables.json');
 import structuredSystemVariables = require('./completion/structuredSystemVariables.json');
+import { currentFile } from '../utils/index.js';
+import { AtelierAPI } from '../api/index.js';
+import { ClassDefinition } from '../utils/classDefinition.js';
 
 export class ObjectScriptHoverProvider implements vscode.HoverProvider {
   provideHover(
@@ -19,21 +22,25 @@ export class ObjectScriptHoverProvider implements vscode.HoverProvider {
     let text = document.getText(
       new vscode.Range(new vscode.Position(position.line, 0), new vscode.Position(position.line, word.end.character))
     );
+    let file = currentFile();
 
     let dollarsMatch = text.match(/(\^?\$+)(\b\w+\b)$/);
     if (dollarsMatch) {
-      let [search, dollars] = dollarsMatch;
+      let range = document.getWordRangeAtPosition(position, /\^?\$+\b\w+\b$/);
+      let [search, dollars, value] = dollarsMatch;
       search = search.toUpperCase();
-      if (dollars === '$' || dollars === '^$') {
+      if (dollars === '$$$') {
+        return this.macro(file.name, value).then(contents => ({
+          range,
+          contents: [contents.join('')]
+        }));
+      } else if (dollars === '$' || dollars === '^$') {
         let found = systemFunctions.find(el => el.label === search || el.alias.includes(search));
         found = found || systemVariables.find(el => el.label === search || el.alias.includes(search));
         found = found || structuredSystemVariables.find(el => el.label === search || el.alias.includes(search));
         if (found) {
           return {
-            range: new vscode.Range(
-              new vscode.Position(word.start.line, word.start.character - dollars.length),
-              new vscode.Position(word.end.line, word.end.character)
-            ),
+            range,
             contents: [found.documentation.join(''), this.documentationLink(found.link)]
           };
         }
@@ -43,6 +50,21 @@ export class ObjectScriptHoverProvider implements vscode.HoverProvider {
     return null;
   }
 
+  async macro(fileName: string, macro: string): Promise<string[]> {
+    const api = new AtelierAPI();
+    let includes = [];
+    if (fileName.toLowerCase().endsWith('cls')) {
+      let classDefinition = new ClassDefinition(fileName);
+      includes = await classDefinition.includeCode();
+    }
+    return api
+      .getmacrodefinition(fileName, macro, includes)
+      .then(data =>
+        data.result.content.definition.map((line: string) => (line.match(/^\s*#def/) ? line : `#define ${line}`))
+      )
+      .then(data => ['```objectscript\n', ...data, '\n```']);
+  }
+
   commands(document: vscode.TextDocument, position: vscode.Position): vscode.ProviderResult<vscode.Hover> {
     let word = document.getWordRangeAtPosition(position);
     let text = document.getText(

Diff for: providers/WorkspaceSymbolProvider.ts

@@ -25,7 +25,7 @@ export class WorkspaceSymbolProvider implements vscode.WorkspaceSymbolProvider {
       return result.map(el => {
         let item;
         let [className, method] = el.ID.split('||');
-        let uri = DocumentContentProvider.getUri(ClassDefinition.normalizeClassName(className));
+        let uri = DocumentContentProvider.getUri(ClassDefinition.normalizeClassName(className, true));
         if (method) {
           item = {
             name: method,

Diff for: utils/classDefinition.ts

@@ -1,12 +1,18 @@
 import { AtelierAPI } from '../api';
 
 export class ClassDefinition {
-  public static normalizeClassName(className): string {
-    return className.replace(/^%(\b\w+\b)$/, '%Library.$1') + '.cls';
+  private _className: string;
+  private _classFileName: string;
+  public static normalizeClassName(className, withExtension = false): string {
+    return className.replace(/^%(\b\w+\b)$/, '%Library.$1') + (withExtension ? '.cls' : '');
   }
 
-  constructor(private _className: string) {
-    this._className = ClassDefinition.normalizeClassName(_className);
+  constructor(className: string) {
+    if (className.endsWith('.cls')) {
+      className = className.replace(/\.cls$/i, '');
+  }
+    this._className = ClassDefinition.normalizeClassName(className, false);
+    this._classFileName = ClassDefinition.normalizeClassName(className, true);
   }
 
   async methods(scope: 'any' | 'class' | 'instance'): Promise<any[]> {
@@ -17,13 +23,28 @@ export class ClassDefinition {
       let extend = [];
       content.forEach(el => {
         methods.push(...el.content.methods);
-        extend.push(...el.content.super.map(extendName => ClassDefinition.normalizeClassName(extendName)));
+        extend.push(...el.content.super.map(extendName => ClassDefinition.normalizeClassName(extendName, true)));
       });
       if (extend.length) {
         return api.actionIndex(extend).then(data => getMethods(data.result.content));
       }
       return methods.filter(filterScope);
     };
-    return api.actionIndex([this._className]).then(data => getMethods(data.result.content));
+    return api.actionIndex([this._classFileName]).then(data => getMethods(data.result.content));
+  }
+
+  async includeCode(): Promise<string[]> {
+    const api = new AtelierAPI();
+    let sql = `SELECT LIST(IncludeCode) List FROM %Dictionary.CompiledClass WHERE Name %INLIST (
+      SELECT $LISTFROMSTRING(PrimarySuper, '~') FROM %Dictionary.CompiledClass WHERE Name = ?)`;
+    let defaultIncludes = ['%occInclude', '%occErrors'];
+    return api
+      .actionQuery(sql, [this._className])
+      .then(data =>
+        data.result.content.reduce(
+          (list: string[], el: { List: string }) => list.concat(el.List.split(',')),
+          defaultIncludes
+        )
+      );
   }
 }