Massive refactoring

codemetrica/SourceParser.ts

@@ -1,30 +1,32 @@
-import { ICodeBlock } from "./interface/ICodeBlock";
-
-import { parsePythonSource } from './language/python/parser';
+import { parsePythonSource } from './language/python/PyParser';
 import { parseJavaSource } from './language/java/parser';
 
 import * as fs from 'fs';
-import { JavaCodeBlock } from './language/java';
-import { PyCodeBlock } from './language/python';
+import { JavaFile } from './language/java';
+import { PyFile } from './language/python';
+
+type CodeFile = PyFile | JavaFile;
 
 export class ParseSource {
-    static fromFile(filePath: string): ICodeBlock {
+    static fromFileSync(filePath: string): CodeFile {
         const extension = filePath.split('.').pop();
 
         if(!extension) {
             throw new Error('No valid file extension');
         }
 
         const text = fs.readFileSync(filePath, 'utf-8');
-        return ParseSource.fromText(text, extension);
+        const file =  ParseSource.fromText(text, extension);
+        file.filePath = filePath;
+        return file;
     }
 
-    static fromText(text: string, extension: string): JavaCodeBlock | PyCodeBlock {
+    static fromText(text: string, extension: string): CodeFile {
         switch(extension) {
             case 'java':
-                return new JavaCodeBlock(parseJavaSource(text));
+                return new JavaFile(parseJavaSource(text));
             case 'py':
-                return new PyCodeBlock(parsePythonSource(text));
+                return new PyFile(parsePythonSource(text));
             default:
                 throw new Error('Unsupported language');
         }

codemetrica/interface/IClass.ts

@@ -1,4 +1,4 @@
-import { ICodeBlock } from './ICodeBlock';
+import { ICodeBlock } from './IFile';
 import { IMethod } from './IMethod';
 
 export interface IClass extends ICodeBlock {

codemetrica/interface/IFile.ts

@@ -0,0 +1,5 @@
+import { Language } from "../language";
+
+export interface IFile {
+    filePath: string | undefined;
+}

codemetrica/interface/IFunction.ts

@@ -1,4 +1,4 @@
-import { ICodeBlock } from './ICodeBlock';
+import { ICodeBlock } from './IFile';
 import { IParameter } from './IParameter';
 
 export interface IFunction extends ICodeBlock{

codemetrica/language/java/JavaClass.ts

@@ -1,9 +1,9 @@
-import { JavaCodeBlockBase } from "./JavaCodeBlockBase";
+import { JavaCodeBlock } from "./JavaCodeBlock";
 import { JavaMethod } from "./JavaMethod";
 import { NormalClassDeclarationContext, MethodDeclarationContext } from "../../../grammars-v4/java/java20/Java20Parser";
 import JavaParserVisitor from "../../../grammars-v4/java/java20/Java20ParserVisitor";
 
-export class JavaClass extends JavaCodeBlockBase<NormalClassDeclarationContext> {
+export class JavaClass extends JavaCodeBlock<NormalClassDeclarationContext> {
     constructor(ctx: NormalClassDeclarationContext) {
         super(ctx);
     }
@@ -13,19 +13,13 @@ export class JavaClass extends JavaCodeBlockBase<NormalClassDeclarationContext>
     }
 
     getMethods(): JavaMethod[] {
-        class MethodVisitor extends JavaParserVisitor<void> {
-            methods: JavaMethod[];
-            constructor() {
-                super();
-                this.methods = [];
+        const visitor = new (class extends JavaParserVisitor<void> {
+            methods: JavaMethod[] = [];
+            visitMethodDeclaration = (ctx: MethodDeclarationContext): void => {
+                this.methods.push(new JavaMethod(ctx));
             }
-
-            visitMethodDeclaration = (ctx: MethodDeclarationContext) => {
-                this.methods.push(new JavaMethod(ctx)); 
-            }
-        }
-
-        const visitor = new MethodVisitor();
+        })();
+
         visitor.visit(this.ctx);
         return visitor.methods; 
     }

codemetrica/language/java/JavaCodeBlock.ts

@@ -1,29 +1,39 @@
-import JavaParserVisitor from "../../../grammars-v4/java/java20/Java20ParserVisitor";
-import { JavaClass } from "./JavaClass";
-import { JavaMethod } from "./JavaMethod";
-import { CompilationUnitContext, NormalClassDeclarationContext, MethodDeclarationContext } from "../../../grammars-v4/java/java20/Java20Parser";
-import { JavaCodeBlockBase } from "./JavaCodeBlockBase";
+import { ParserRuleContext } from 'antlr4';
+import { StatementContext } from '../../../grammars-v4/java/java20/Java20Parser';
+import JavaParserVisitor from '../../../grammars-v4/java/java20/Java20ParserVisitor';
+import { Language } from '../../language';
 
-export class JavaCodeBlock extends JavaCodeBlockBase<CompilationUnitContext> {
-    constructor(ctx: CompilationUnitContext) {
-        super(ctx);
-    }
+export abstract class JavaCodeBlock<T extends ParserRuleContext> {
+  ctx: T
+  language: Language
 
-    getClasses(): JavaClass[] {
-        class ClassVisitor extends JavaParserVisitor<void> {
-            classes: JavaClass[];
-            constructor() {
-                super();
-                this.classes = [];
-            }
+  constructor(ctx: T) {
+      this.ctx = ctx;
+      this.language = Language.JAVA;
+  }
 
-            visitNormalClassDeclaration = (ctx: NormalClassDeclarationContext) => {
-                this.classes.push(new JavaClass(ctx)); 
-            }
-        }
+  getClasses() {
+    throw new Error("Method getClasses() must be implemented");
+  }
 
-        const visitor = new ClassVisitor();
-        visitor.visit(this.ctx);
-        return visitor.classes;
-    }
-}
+  getFunctions() {
+    throw new Error("Method getFunctions() must be implemented");
+  }
+
+  getMethods() {
+    throw new Error("Method getMethods() must be implemented");
+  }
+
+  getSimpleStatements(): StatementContext[]  {
+    const visitor = new (class extends JavaParserVisitor<void> {
+      statements: StatementContext[] = [];
+
+      visitStatement = (ctx: StatementContext): void => {
+        this.statements.push(ctx);
+      }
+    })();
+
+    visitor.visit(this.ctx);
+    return visitor.statements;
+  }
+}

codemetrica/language/java/JavaFile.ts

@@ -0,0 +1,25 @@
+import JavaParserVisitor from "../../../grammars-v4/java/java20/Java20ParserVisitor";
+import { JavaClass } from "./JavaClass";
+import { CompilationUnitContext, NormalClassDeclarationContext } from "../../../grammars-v4/java/java20/Java20Parser";
+import { JavaCodeBlock } from "./JavaCodeBlock";
+import { IFile } from "../../interface/IFile";
+
+export class JavaFile extends JavaCodeBlock<CompilationUnitContext> implements IFile{
+    filePath: string | undefined;
+
+    constructor(ctx: CompilationUnitContext) {
+        super(ctx);
+    }
+
+    getClasses(): JavaClass[] {
+        const visitor = new (class extends JavaParserVisitor<void> {
+            classes: JavaClass[] = [];
+            visitNormalClassDeclaration = (ctx: NormalClassDeclarationContext): void => {
+                this.classes.push(new JavaClass(ctx));
+            }
+        })();
+
+        visitor.visit(this.ctx);
+        return visitor.classes;
+    }
+}

codemetrica/language/java/JavaMethod.ts

@@ -1,10 +1,9 @@
 
 import { IMethod } from '../../interface/IMethod';
-import { JavaCodeBlockBase } from "./JavaCodeBlockBase";
+import { JavaCodeBlock } from "./JavaCodeBlock";
 import { MethodDeclarationContext } from "../../../grammars-v4/java/java20/Java20Parser";
-import { IParameter } from '../../interface/IParameter';
-
-export class JavaMethod extends JavaCodeBlockBase<MethodDeclarationContext> implements IMethod {
+import { JavaParameter } from './JavaParameter';
+export class JavaMethod extends JavaCodeBlock<MethodDeclarationContext> implements IMethod {
   constructor(ctx: MethodDeclarationContext) {
     super(ctx);
   }
@@ -14,12 +13,12 @@ export class JavaMethod extends JavaCodeBlockBase<MethodDeclarationContext> impl
   }
 
   getParameters() {
-    const parameters: IParameter[] = [];
+    const parameters: JavaParameter[] = [];
 
-    const paramCtx = this.ctx.MethodDeclaration()?.params()?.parameters()?.children || []
+    const paramCtx = this.ctx?.methodHeader()?.typeParameters()?.children || []
 
     paramCtx.forEach((param: any) => {
-      parameters.push(new Parameter(param.getText(), "lol"));
+      parameters.push(new JavaParameter(param.getText(), "lol"));
     });
 
     return parameters;

codemetrica/language/java/JavaParameter.ts

@@ -1,12 +1,10 @@
 import { IParameter } from "../../interface/IParameter";
-import { JavaCodeBlockBase } from "./JavaCodeBlockBase";
 
-export class Parameter extends JavaCodeBlockBase<> implements IParameter {
+export class JavaParameter implements IParameter {
     name: string;
     type: string;
 
     constructor(name: string, type: string) {
-        super();
         this.name = name;
         this.type = type;
     }

codemetrica/language/java/index.ts

@@ -3,7 +3,7 @@
  */
 
 export * from "./JavaClass";
-export * from "./JavaCodeBlockBase";
 export * from "./JavaCodeBlock";
+export * from "./JavaFile";
 export * from "./JavaMethod";
 export * from "./parser";