ts2famix 1.3.0 → 1.4.0

package/src/analyze.ts

@@ -1,31 +1,28 @@
 import { Project } from "ts-morph";
 import * as fs from 'fs';
 import { FamixRepository } from "./lib/famix/src/famix_repository";
-import { FamixFunctions } from "./famix_functions/famix_functions";
-import { ProcessFiles } from "./analyze_functions/processFiles";
-import { ProcessAccesses } from "./analyze_functions/processAccesses";
-import { ProcessInvocations } from "./analyze_functions/processInvocations";
-import { ProcessInheritances } from "./analyze_functions/processInheritances";
-import { ProcessImportClauses } from "./analyze_functions/processImportClauses";
-
 import { Logger } from "tslog";
+import * as processFunctions from "./analyze_functions/process_functions";
+import { EntityDictionary } from "./famix_functions/EntityDictionary";
+import path from "path";
 
 export const logger = new Logger({ name: "ts2famix", minLevel: 3});
 export const config = { "expectGraphemes": false };
+export const entityDictionary = new EntityDictionary();
 
 /**
  * This class is used to build a Famix model from a TypeScript source code
  */
 export class Importer {
 
-    private project = new Project(); // The project containing the source files to analyze
-    private famixFunctions = new FamixFunctions(); // FamixFunctions object, it contains all the functions needed to create Famix entities
-    private processFiles = new ProcessFiles(this.famixFunctions); // ProcessFiles object, it contains all the functions needed to process the source files
-    private processAccesses = new ProcessAccesses(this.famixFunctions); // ProcessAccesses object, it contains all the functions needed to process the accesses
-    private processInvocations = new ProcessInvocations(this.famixFunctions); // ProcessInvocations object, it contains all the functions needed to process the invocations
-    private processInheritances = new ProcessInheritances(this.famixFunctions); // ProcessInheritances object, it contains all the functions needed to process the inheritances
-    private processImportClauses = new ProcessImportClauses(this.famixFunctions); // ProcessImportClauses object, it contains all the functions needed to process the import clauses
-
+    private project = new Project(
+        {
+            compilerOptions: {
+                baseUrl: "./test_src"
+            }
+        }
+    ); // The project containing the source files to analyze
+    
     /**
      * Main method
      * @param paths An array of paths to the source files to analyze
@@ -36,9 +33,12 @@ export class Importer {
 //        try {
         logger.debug(`famixRepFromPaths: paths: ${paths}`);
         this.project.addSourceFilesAtPaths(paths);
+
+        initFamixRep(this.project);
+
         this.processEntities(this.project);
 
-        const famixRep = this.famixFunctions.getFamixRepository();
+        const famixRep = entityDictionary.famixRep;
 //        }
 //        catch (error) {
             // logger.error(`> ERROR: got exception ${error}. Exiting...`);
@@ -51,18 +51,19 @@ export class Importer {
     }
 
     private processEntities(project) {
-        this.processFiles.processFiles(project.getSourceFiles());
-        const accesses = this.processFiles.getAccesses();
-        const methodsAndFunctionsWithId = this.processFiles.getMethodsAndFunctionsWithId();
-        const classes = this.processFiles.getClasses();
-        const interfaces = this.processFiles.getInterfaces();
-        const modules = this.processFiles.getModules();
-        const exports = this.processFiles.getExports();
-
-        this.processImportClauses.processImportClauses(modules, exports);
-        this.processAccesses.processAccesses(accesses);
-        this.processInvocations.processInvocations(methodsAndFunctionsWithId);
-        this.processInheritances.processInheritances(classes, interfaces);
+        processFunctions.processFiles(project.getSourceFiles());
+        const accesses = processFunctions.accessMap;
+        const methodsAndFunctionsWithId = processFunctions.methodsAndFunctionsWithId;
+        const classes = processFunctions.classes;
+        const interfaces = processFunctions.interfaces;
+        const modules = processFunctions.modules;
+        const exports = processFunctions.exportedMap;
+
+        processFunctions.processImportClausesForImportEqualsDeclarations(project.getSourceFiles(), exports);
+        processFunctions.processImportClausesForModules(modules, exports);
+        processFunctions.processAccesses(accesses);
+        processFunctions.processInvocations(methodsAndFunctionsWithId);
+        processFunctions.processInheritances(classes, interfaces);
     }
 
     /**
@@ -92,9 +93,25 @@ export class Importer {
         //const sourceFileNames = project.getSourceFiles().map(f => f.getFilePath()) as Array<string>;
 
         //const famixRep = this.famixRepFromPaths(sourceFileNames);
+
+        initFamixRep(project);
+        
         this.processEntities(project);
 
-        return this.famixFunctions.getFamixRepository();
+        return entityDictionary.famixRep;
     }
 
 }
+
+function initFamixRep(project :Project ): void {
+    
+        // get compiler options
+        const compilerOptions = project.getCompilerOptions();
+
+        // get baseUrl
+        const baseUrl = compilerOptions.baseUrl;
+
+        const absoluteBaseUrl = path.resolve(baseUrl);
+
+        entityDictionary.famixRep.setAbsolutePath(path.normalize(absoluteBaseUrl));
+}