Merge pull request #227 from salesforcecli/u/abhinavkumar2/apex-parser/W-16427555

@W-16427555 Apex parser integration

Author: AbhinavKumar-sf

package.json

@@ -5,6 +5,7 @@
   "author": "Salesforce",
   "bugs": "https://github.com/forcedotcom/cli/issues",
   "dependencies": {
+    "@apexdevtools/apex-parser": "^4.1.0",
     "@oclif/command": "^1",
     "@oclif/config": "^1",
     "@oclif/errors": "^1",

src/utils/apex/parser/apexparser.ts

@@ -0,0 +1,89 @@
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+import {
+  ApexLexer,
+  CommonTokenStream,
+  ApexParser,
+  CaseInsensitiveInputStream,
+  ApexParserListener,
+  ClassDeclarationContext,
+  DotExpressionContext,
+  VariableDeclaratorContext,
+  CompilationUnitContext,
+} from '@apexdevtools/apex-parser';
+import { CharStreams, Token } from 'antlr4ts';
+import { ParseTreeWalker } from 'antlr4ts/tree/ParseTreeWalker';
+
+export class ApexASTParser {
+  private apexFileContent: string;
+  private implementsInterface: Map<string, Token> = new Map();
+  // private callsMethods: Map<string, Token[]>;
+  private interfaceName: string;
+  private methodName: string;
+  // private className: string;
+  private astListener: ApexParserListener;
+
+  public get implemementsInterface(): Map<string, Token> {
+    return this.implementsInterface;
+  }
+
+  public constructor(apexFileContent: string, interfaceName: string, methodName: string) {
+    this.apexFileContent = apexFileContent;
+    this.interfaceName = interfaceName;
+    this.methodName = methodName;
+    this.astListener = this.createASTListener();
+  }
+
+  public parse(): CompilationUnitContext {
+    const lexer = new ApexLexer(new CaseInsensitiveInputStream(CharStreams.fromString(this.apexFileContent)));
+    const tokens = new CommonTokenStream(lexer);
+    const parser = new ApexParser(tokens);
+    const context = parser.compilationUnit();
+    //  parser.addParseListener(new interfaceVisitor() as ApexParserListener);
+    ParseTreeWalker.DEFAULT.walk(this.astListener, context);
+    return context;
+  }
+
+  private createASTListener(): ApexParserListener {
+    class ApexMigrationListener implements ApexParserListener {
+      public constructor(private parser: ApexASTParser) {}
+      public enterClassDeclaration(ctx: ClassDeclarationContext): void {
+        const interfaceToBeSearched = this.parser.interfaceName;
+        if (!interfaceToBeSearched) return;
+        if (!ctx.typeList() || !ctx.typeList().typeRef()) return;
+        for (const typeRefContext of ctx.typeList().typeRef())
+          for (const typeNameContext of typeRefContext.typeName()) {
+            if (!typeNameContext.id() || !typeNameContext.id().Identifier()) continue;
+            if (typeNameContext.id().Identifier().symbol.text === interfaceToBeSearched) {
+              this.parser.implementsInterface.set(interfaceToBeSearched, typeNameContext.id().Identifier().symbol);
+            }
+          }
+      }
+
+      public enterDotExpression(ctx: DotExpressionContext): void {
+        // console.log('*********');
+        // console.log(ctx.expression().start.text);
+        if (ctx.dotMethodCall() && this.parser.methodName) {
+          // console.log(ctx.dotMethodCall().anyId().Identifier().symbol.text);
+          // ctx.dotMethodCall().expressionList().expression(1).children[0].children[0].children[0];
+          // console.log(ctx.dotMethodCall().expressionList().expression(1).children[0]);
+        }
+        // console.log('*********');
+      }
+
+      public enterVariableDeclarator(ctx: VariableDeclaratorContext): void {
+        if (ctx.id().Identifier().symbol.text === 'DRName') {
+          // console.log(ctx.expression());
+        }
+      }
+    }
+    return new ApexMigrationListener(this);
+  }
+}
+
+// const filePath = '/Users/abhinavkumar2/company/plugin-omnistudio-migration-tool/test/FormulaParserService.cls';
+// new ApexASTParser(filePath, 'callable', '').parse(filePath);
+
+// console.log(ast);

test/commands/omnistudio/migration/info.test.ts

@@ -21,8 +21,6 @@ describe('omnistudio:migration:info', () => {
     .stdout()
     .command(['omnistudio:migration:info', '--targetusername', '[email protected]', '--allversions'])
     .it('runs omnistudio:migration:info --targetusername [email protected] --allversions', (ctx) => {
-      expect(ctx.stdout).to.contain(
-        'Hello world! This is org: Super Awesome Org and I will be around until Tue Mar 20 2018!'
-      );
+      expect(ctx.stdout).to.contain('Hello world! This is org: Super Awesome Org');
     });
 });

test/utils/apex/parser/FormulaParserService.cls

@@ -0,0 +1,49 @@
+/*
+   The service implements Callable to support calling
+   FormulaParser functions from Core/Java.
+   The allowed functions are listed in FormulaParser FUNCTIONS_FROM_JAVA.
+*/
+global with sharing class FormulaParserService implements Callable
+{
+   /* global Object call(String action, Map<String, Object> args)
+    {
+        Map<String, Object> input = (Map<String, Object>) args.get('input');
+        Map<String, Object> output = (Map<String, Object>) args.get('output');
+
+        String function = (String)input.get('function');
+        if (function == null || String.isBlank(function))
+        {
+            return null;
+        }
+
+        List<Object> arguments = (input.get('arguments') != null && input.get('arguments') InstanceOf List<Object>)
+                    ? (List<Object>)input.get('arguments') : new List<Object>();
+
+        if (action == 'evaluateFunctionFromJava')
+        {
+            Object res = FormulaParser.evaluateFunctionFromJava(function, arguments);
+            if (res != null)
+            {
+                output.put('result', res);
+            }
+        }
+        return null;
+    }
+
+    global void evaluateFunctionFromJava(String function, List<Object> arguments)
+    {
+        Map < String, Object > testMap = new Map < String, Object > { 'BirthDate' => '1982-11-06' };
+		DRProcessResult result = DRGlobal.process(testMap, 'DRTurboTemp2');
+		//List < Object > resultMap = (List < Object >)((Map < String, Object >)result.toJson()).get('Contact');
+		//System.assertEquals(Date.newInstance(1982, 11, 6), ((Map < String, Object >)resultMap[0]).get('Birthdate'));
+    }*/
+
+    global void justForTest(String kkdbk) {
+        /* Specify Data Mapper extract or transform to call */
+        String DRName = 'DataMapperNewName'; 
+        /* Populate the input JSON */ 
+        Map<String, Object> myTransformData = new Map<String, Object>{'MyKey'=>'MyValue'}; 
+        /* Call the Data Mapper */ 
+        omnistudio.DRProcessResult result1 = omnistudio.DRGlobal.process(myTransformData, DRName);
+    }
+}

test/utils/apex/parser/apexparser.test.ts

@@ -0,0 +1,33 @@
+import { expect } from '@salesforce/command/lib/test';
+import { ApexASTParser } from '../../../../src/utils/apex/parser/apexparser';
+
+describe('ApexASTParser', () => {
+  it('should parse the Apex file and collect interface implementations, method calls, and class names', () => {
+    const apexFileContent = `global with sharing class FormulaParserService implements Callable{
+
+        global void justForTest(String kkdbk) {
+        /* Specify Data Mapper extract or transform to call */
+        String DRName = 'DataMapperNewName'; 
+        /* Populate the input JSON */ 
+        Map<String, Object> myTransformData = new Map<String, Object>{'MyKey'=>'MyValue'}; 
+        /* Call the Data Mapper */ 
+        omnistudio.DRProcessResult result1 = omnistudio.DRGlobal.process(myTransformData, DRName);
+    }
+    }`;
+    const interfaceName = 'Callable';
+    const methodName = 'yourMethod';
+
+    const apexParser = new ApexASTParser(apexFileContent, interfaceName, methodName);
+    apexParser.parse();
+    const implementsInterface = apexParser.implemementsInterface;
+    // const callsMethods = apexParser.getCallsMethods();
+    // const className = apexParser.getClassName();
+
+    // Add your assertions here based on the expected results
+    // implementsInterface.get(interfaceName);
+    expect(implementsInterface.get(interfaceName).charPositionInLine).to.be.equal(58);
+    expect(implementsInterface.get(interfaceName).line).to.be.equal(1);
+    // expect(callsMethods).to.not.be.empty;
+    // expect(className).to.equal('YourClass');
+  });
+});