ts2famix 1.0.7 → 1.0.9

package/dist/ts2famix-cli.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -29,17 +30,29 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
 const yargs_1 = __importDefault(require("yargs"));
 const analyze_1 = require("./analyze");
-const importer = new analyze_1.Importer();
+const ts_morph_1 = require("ts-morph");
 const argv = yargs_1.default
-    .example(`ts-node src/ts2famix-cli.ts -i "../path/to/project/**/*.ts" -o JSONModels/projectName.json`, 'creates a JSON-format model of a typescript project')
+    .example(`ts2famix -i "path/to/project/**/*.ts" -o JSONModels/projectName.json`, 'Creates a JSON-format Famix model of typescript files.')
+    .example(`ts2famix -i path/to/tsconfig.json -o JSONModels/projectName.json`, 'Creates a JSON-format model of a typescript project.')
     .alias('i', 'input')
     .nargs('i', 1)
     .alias('o', 'output')
     .nargs('o', 1)
     .demandOption('input').demandOption('output').parseSync();
-const paths = new Array();
-paths.push(argv.input);
-const famixRep = importer.famixRepFromPaths(paths);
+const importer = new analyze_1.Importer();
+let famixRep;
+if (argv.input.endsWith('tsconfig.json')) {
+    const tsConfigFilePath = argv.input;
+    const project = new ts_morph_1.Project({
+        tsConfigFilePath
+    });
+    famixRep = importer.famixRepFromProject(project);
+}
+else {
+    const paths = new Array();
+    paths.push(argv.input);
+    famixRep = importer.famixRepFromPaths(paths);
+}
 const jsonOutput = famixRep.getJSON();
 const jsonFilePath = argv.output;
 fs.writeFile(jsonFilePath, jsonOutput, (err) => {

package/metrics.ts

@@ -0,0 +1,23 @@
+class ForMetrics {
+    public methodCyclomaticOne() {}
+    
+    public methodCyclomaticFour() {
+        // make higher cyclomatic complexity
+        for (let i = 0; i < 50; i++) { // 2
+            for (let j = 0; j < 50; j++) { // 3
+                if (i < 10) {} // 4
+            }
+        }
+    }
+}
+
+function functionCyclomaticOne() {}
+
+function functionCyclomaticFour() {
+    // make higher cyclomatic complexity
+    for (let i = 0; i < 50; i++) { // 2
+        for (let j = 0; j < 50; j++) { // 3
+            if (i < 10) {} // 4
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts2famix",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Examples of the TypeScript compiler API usage",
   "main": "dist/ts2famix-cli.js",
   "scripts": {

package/src/analyze.ts

@@ -27,44 +27,47 @@ export class Importer {
      * @returns The Famix repository containing the Famix model
      */
     public famixRepFromPaths(paths: Array<string>): FamixRepository {
-        let famixRep: FamixRepository;
 
-        try {
-            console.info(`famixRepFromPaths: paths: ${paths}`);
+//        try {
+        console.info(`famixRepFromPaths: paths: ${paths}`);
+        this.project.addSourceFilesAtPaths(paths);
+        this.processEntities(this.project);
 
-            const sourceFiles = this.project.addSourceFilesAtPaths(paths);
-            this.processFiles.processFiles(sourceFiles);
-
-            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);
-
-            famixRep = this.famixFunctions.getFamixRepository();
-        }
-        catch (error) {
-            console.error(`> ERROR: got exception ${error}. Exiting...`);
-            console.error(error.message);
-            console.error(error.stack);
-            process.exit(1);
-        }
+        const famixRep = this.famixFunctions.getFamixRepository();
+//        }
+//        catch (error) {
+            // console.error(`> ERROR: got exception ${error}. Exiting...`);
+            // console.error(error.message);
+            // console.error(error.stack);
+            // process.exit(1);
+//        }
 
         return famixRep;
     }
 
+    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);
+    }
+
     /**
      * Main method for tests
+     *
      * @param filename The name of the file to analyze
      * @param source A TypeScript source code
      * @returns The Famix repository containing the Famix model
      */
+    // TODO: this is slow because it writes the source code to a file and then reads it again - it's possible to just pass the source code to the ts-morph project
     public famixRepFromSource(filename: string, source: string): FamixRepository {
         const filePath = `./test_src/${filename}.ts`;
 
@@ -81,10 +84,11 @@ export class Importer {
      * @returns The Famix repository containing the Famix model
      */
     public famixRepFromProject(project: Project): FamixRepository {
-        const sourceFileNames = project.getSourceFiles().map(f => f.getFilePath()) as Array<string>;
+        //const sourceFileNames = project.getSourceFiles().map(f => f.getFilePath()) as Array<string>;
 
-        const famixRep = this.famixRepFromPaths(sourceFileNames);
+        //const famixRep = this.famixRepFromPaths(sourceFileNames);
+        this.processEntities(project);
 
-        return famixRep;
+        return this.famixFunctions.getFamixRepository();
     }
 }

package/src/analyze_functions/processFiles.ts

@@ -2,6 +2,7 @@ import { ClassDeclaration, MethodDeclaration, VariableStatement, FunctionDeclara
 import * as Famix from "../lib/famix/src/model/famix";
 import { FamixFunctions } from "../famix_functions/famix_functions";
 import { calculate } from "../lib/ts-complex/cyclomatic-service";
+import * as fs from 'fs';
 
 /**
  * This class is used to build a Famix model for an array of source files
@@ -33,8 +34,11 @@ export class ProcessFiles {
         sourceFiles.forEach(file => {
             console.info(`processFiles: File: >>>>>>>>>> ${file.getBaseName()}`);
 
-            // Computes the cyclomatic complexity metrics for the current source file
-            this.currentCC = calculate(file.getFilePath());
+            // Computes the cyclomatic complexity metrics for the current source file if it exists (i.e. if it is not from a jest test)
+            if (fs.existsSync(file.getFilePath()))
+                this.currentCC = calculate(file.getFilePath());
+            else
+                this.currentCC = 0;
 
             this.processFile(file);
         });

package/src/analyze_functions/processInheritances.ts

@@ -21,7 +21,7 @@ export class ProcessInheritances {
      * @param classes An array of classes
      * @param interfaces An array of interfaces
      */
-    public processInheritances(classes: Array<ClassDeclaration>, interfaces: Array<InterfaceDeclaration>): void {
+    public processInheritances(classes: ClassDeclaration[], interfaces: InterfaceDeclaration[]): void {
         console.info(`processInheritances: Creating inheritances:`);
         classes.forEach(cls => {
             console.info(`processInheritances: Checking class inheritance for ${cls.getName()}`);

package/src/famix_functions/famix_functions.ts

@@ -13,13 +13,13 @@ export class FamixFunctions {
 
     private famixRep = new FamixRepository(); // The Famix repository
     private FQNFunctions = new FQNFunctions(); // The fully qualified name functions
-    private fmxAliases = new Map<string, Famix.Alias>(); // Maps the alias names to their Famix model
-    private fmxClasses = new Map<string, Famix.Class | Famix.ParameterizableClass>(); // Maps the class names to their Famix model
-    private fmxInterfaces = new Map<string, Famix.Interface | Famix.ParameterizableInterface>(); // Maps the interface names to their Famix model
-    private fmxNamespaces = new Map<string, Famix.Namespace>(); // Maps the namespace names to their Famix model
-    private fmxFiles = new Map<string, Famix.ScriptEntity | Famix.Module>(); // Maps the source file names to their Famix model
+    private fmxAliasMap = new Map<string, Famix.Alias>(); // Maps the alias names to their Famix model
+    private fmxClassMap = new Map<string, Famix.Class | Famix.ParameterizableClass>(); // Maps the fully qualifiedclass names to their Famix model
+    private fmxInterfaceMap = new Map<string, Famix.Interface | Famix.ParameterizableInterface>(); // Maps the interface names to their Famix model
+    private fmxNamespaceMap = new Map<string, Famix.Namespace>(); // Maps the namespace names to their Famix model
+    private fmxFileMap = new Map<string, Famix.ScriptEntity | Famix.Module>(); // Maps the source file names to their Famix model
     private famixFunctionsIndex = new FamixFunctionsIndex(this.famixRep); // FamixFunctionsIndex object, it contains all the functions needed to create Famix index file anchors
-    private famixFunctionsAssociations = new FamixFunctionsAssociations(this.famixRep, this.fmxClasses, this.fmxInterfaces); // FamixFunctionsAssociations object, it contains all the functions needed to create Famix associations
+    private famixFunctionsAssociations = new FamixFunctionsAssociations(this.famixRep, this.fmxClassMap, this.fmxInterfaceMap); // FamixFunctionsAssociations object, it contains all the functions needed to create Famix associations
     private famixFunctionsTypes = new FamixFunctionsTypes(this.famixRep); // FamixFunctionsTypes object, it contains all the functions needed to create Famix types
     private UNKNOWN_VALUE = '(unknown due to parsing error)'; // The value to use when a name is not usable
 
@@ -40,7 +40,7 @@ export class FamixFunctions {
     public createOrGetFamixFile(f: SourceFile, isModule: boolean): Famix.ScriptEntity | Famix.Module {
         let fmxFile: Famix.ScriptEntity | Famix.Module;
         const fileName = f.getBaseName();
-        if (!this.fmxFiles.has(fileName)) {
+        if (!this.fmxFileMap.has(fileName)) {
             if (isModule) {
                 fmxFile = new Famix.Module(this.famixRep); 
             }
@@ -53,10 +53,10 @@ export class FamixFunctions {
 
             this.famixFunctionsIndex.makeFamixIndexFileAnchor(f, fmxFile);
 
-            this.fmxFiles.set(fileName, fmxFile);
+            this.fmxFileMap.set(fileName, fmxFile);
         }
         else {
-            fmxFile = this.fmxFiles.get(fileName);
+            fmxFile = this.fmxFileMap.get(fileName);
         }
         return fmxFile;
     }
@@ -69,16 +69,16 @@ export class FamixFunctions {
     public createOrGetFamixNamespace(m: ModuleDeclaration): Famix.Namespace {
         let fmxNamespace: Famix.Namespace;
         const namespaceName = m.getName();
-        if (!this.fmxNamespaces.has(namespaceName)) {
+        if (!this.fmxNamespaceMap.has(namespaceName)) {
             fmxNamespace = new Famix.Namespace(this.famixRep);
             fmxNamespace.setName(namespaceName);
 
             this.famixFunctionsIndex.makeFamixIndexFileAnchor(m, fmxNamespace);
 
-            this.fmxNamespaces.set(namespaceName, fmxNamespace);
+            this.fmxNamespaceMap.set(namespaceName, fmxNamespace);
         }
         else {
-            fmxNamespace = this.fmxNamespaces.get(namespaceName);
+            fmxNamespace = this.fmxNamespaceMap.get(namespaceName);
         }
         return fmxNamespace;
     }
@@ -91,7 +91,7 @@ export class FamixFunctions {
     public createFamixAlias(a: TypeAliasDeclaration): Famix.Alias {
         let fmxAlias: Famix.Alias;
         const aliasName = a.getName();
-        if (!this.fmxAliases.has(aliasName)) {
+        if (!this.fmxAliasMap.has(aliasName)) {
             fmxAlias = new Famix.Alias(this.famixRep);
             fmxAlias.setName(a.getName());
 
@@ -100,10 +100,10 @@ export class FamixFunctions {
 
             this.famixFunctionsIndex.makeFamixIndexFileAnchor(a, fmxAlias);
 
-            this.fmxAliases.set(aliasName, fmxAlias);
+            this.fmxAliasMap.set(aliasName, fmxAlias);
         }
         else {
-            fmxAlias = this.fmxAliases.get(aliasName);
+            fmxAlias = this.fmxAliasMap.get(aliasName);
         }
         return fmxAlias;
     }
@@ -116,8 +116,9 @@ export class FamixFunctions {
     public createOrGetFamixClass(cls: ClassDeclaration): Famix.Class | Famix.ParameterizableClass {
         let fmxClass: Famix.Class | Famix.ParameterizableClass;
         const isAbstract = cls.isAbstract();
+        const classFullyQualifiedName = this.FQNFunctions.getFQN(cls);
         const clsName = cls.getName();
-        if (!this.fmxClasses.has(clsName)) {
+        if (!this.fmxClassMap.has(classFullyQualifiedName)) {
             const isGeneric = cls.getTypeParameters().length;
             if (isGeneric) {
                 fmxClass = new Famix.ParameterizableClass(this.famixRep);
@@ -127,14 +128,15 @@ export class FamixFunctions {
             }
 
             fmxClass.setName(clsName);
+            fmxClass.setFullyQualifiedName(classFullyQualifiedName);
             fmxClass.setIsAbstract(isAbstract);
 
             this.famixFunctionsIndex.makeFamixIndexFileAnchor(cls, fmxClass);
 
-            this.fmxClasses.set(clsName, fmxClass);
+            this.fmxClassMap.set(classFullyQualifiedName, fmxClass);
         }
         else {
-            fmxClass = this.fmxClasses.get(clsName) as (Famix.Class | Famix.ParameterizableClass);
+            fmxClass = this.fmxClassMap.get(classFullyQualifiedName) as (Famix.Class | Famix.ParameterizableClass);
         }
         return fmxClass;
     }
@@ -147,7 +149,8 @@ export class FamixFunctions {
     public createOrGetFamixInterface(inter: InterfaceDeclaration): Famix.Interface | Famix.ParameterizableInterface {
         let fmxInterface: Famix.Interface | Famix.ParameterizableInterface;
         const interName = inter.getName();
-        if (!this.fmxInterfaces.has(interName)) {
+        const interFullyQualifiedName = this.FQNFunctions.getFQN(inter);
+        if (!this.fmxInterfaceMap.has(interName)) {
             const isGeneric = inter.getTypeParameters().length;
             if (isGeneric) {
                 fmxInterface = new Famix.ParameterizableInterface(this.famixRep);
@@ -160,10 +163,10 @@ export class FamixFunctions {
 
             this.famixFunctionsIndex.makeFamixIndexFileAnchor(inter, fmxInterface);
 
-            this.fmxInterfaces.set(interName, fmxInterface);
+            this.fmxInterfaceMap.set(interFullyQualifiedName, fmxInterface);
         }
         else {
-            fmxInterface = this.fmxInterfaces.get(interName) as (Famix.Interface | Famix.ParameterizableInterface);
+            fmxInterface = this.fmxInterfaceMap.get(interName) as (Famix.Interface | Famix.ParameterizableInterface);
         }
         return fmxInterface;
     }

package/src/famix_functions/famix_functions_associations.ts

@@ -11,20 +11,20 @@ export class FamixFunctionsAssociations {
 
     private famixRep: FamixRepository; // The Famix repository
     private FQNFunctions = new FQNFunctions(); // The fully qualified name functions
-    private famixClasses: Map<string, Famix.Class | Famix.ParameterizableClass>; // Maps the class names to their Famix model
-    private famixInterfaces: Map<string, Famix.Interface | Famix.ParameterizableInterface>; // Maps the interface names to their Famix model
+    private famixClassMap: Map<string, Famix.Class | Famix.ParameterizableClass>; // Maps the class names to their Famix model
+    private famixInterfaceMap: Map<string, Famix.Interface | Famix.ParameterizableInterface>; // Maps the interface names to their Famix model
     private famixFunctionsIndex: FamixFunctionsIndex; // FamixFunctionsIndex object, it contains all the functions needed to create Famix index file anchors
 
     /**
      * Initializes the FamixFunctionsAssociations object
      * @param famixRep The Famix repository
-     * @param fmxClasses The map of the class names and their Famix model
-     * @param fmxInterfaces The map of the interface names and their Famix model
+     * @param fmxClassMap The map of the class names and their Famix model
+     * @param fmxInterfaceMap The map of the interface names and their Famix model
      */
-    constructor(famixRep: FamixRepository, fmxClasses: Map<string, Famix.Class | Famix.ParameterizableClass>, fmxInterfaces: Map<string, Famix.Interface | Famix.ParameterizableInterface>) {
+    constructor(famixRep: FamixRepository, fmxClassMap: Map<string, Famix.Class | Famix.ParameterizableClass>, fmxInterfaceMap: Map<string, Famix.Interface | Famix.ParameterizableInterface>) {
         this.famixRep = famixRep;
-        this.famixClasses = fmxClasses;
-        this.famixInterfaces = fmxInterfaces;
+        this.famixClassMap = fmxClassMap;
+        this.famixInterfaceMap = fmxInterfaceMap;
         this.famixFunctionsIndex = new FamixFunctionsIndex(famixRep);
     }
 
@@ -76,42 +76,49 @@ export class FamixFunctionsAssociations {
      */
     public createFamixInheritance(cls: ClassDeclaration | InterfaceDeclaration, inhClass: ClassDeclaration | InterfaceDeclaration | ExpressionWithTypeArguments): void {
         const fmxInheritance = new Famix.Inheritance(this.famixRep);
-        const clsName = cls.getName();
-        
+        // const clsName = cls.getName();
+        const classFullyQualifiedName = this.FQNFunctions.getFQN(cls);
+        console.info(`createFamixInheritance: classFullyQualifiedName: class fqn = ${classFullyQualifiedName}`);
         let subClass: Famix.Class | Famix.Interface;
         if (cls instanceof ClassDeclaration) {
-            subClass = this.famixClasses.get(clsName);
+            subClass = this.famixClassMap.get(classFullyQualifiedName);
         }
         else {
-            subClass = this.famixInterfaces.get(clsName);
+            subClass = this.famixInterfaceMap.get(classFullyQualifiedName);
         }
         
         let inhClassName: string;
+        let inhClassFullyQualifiedName: string;
         let superClass: Famix.Class | Famix.Interface;
         if (inhClass instanceof ClassDeclaration || inhClass instanceof InterfaceDeclaration) {
             inhClassName = inhClass.getName();
+            inhClassFullyQualifiedName = this.FQNFunctions.getFQN(inhClass);
             if (inhClass instanceof ClassDeclaration) {
-                superClass = this.famixClasses.get(inhClassName);
+                superClass = this.famixClassMap.get(inhClassFullyQualifiedName);
             }
             else {
-                superClass = this.famixInterfaces.get(inhClassName);
+                superClass = this.famixInterfaceMap.get(inhClassFullyQualifiedName);
             }
         }
         else {
+            // inhClass is an ExpressionWithTypeArguments
             inhClassName = inhClass.getExpression().getText();
+            // what is inhClassFullyQualifiedName? TODO
+            inhClassFullyQualifiedName = 'Undefined_Scope_from_importer.' + inhClassName;
         }
 
         if (superClass === undefined) {
             if (inhClass instanceof ClassDeclaration) {
                 superClass = new Famix.Class(this.famixRep);
-                this.famixClasses.set(inhClassName, superClass);
+                this.famixClassMap.set(inhClassFullyQualifiedName, superClass);
             }
             else {
                 superClass = new Famix.Interface(this.famixRep);
-                this.famixInterfaces.set(inhClassName, superClass);
+                this.famixInterfaceMap.set(inhClassFullyQualifiedName, superClass);
             }
 
             superClass.setName(inhClassName);
+            superClass.setFullyQualifiedName(inhClassFullyQualifiedName);
             superClass.setIsStub(true);
 
             this.famixFunctionsIndex.makeFamixIndexFileAnchor(inhClass, superClass);

package/src/ts2famix-cli.ts

@@ -1,21 +1,34 @@
+#!/usr/bin/env node
 import * as fs from "fs";
 import yargs from "yargs";
 import { Importer } from './analyze';
-
-const importer = new Importer();
+import { FamixRepository } from "./lib/famix/src/famix_repository";
+import { Project } from "ts-morph";
 
 const argv = yargs
-    .example(`ts-node src/ts2famix-cli.ts -i "../path/to/project/**/*.ts" -o JSONModels/projectName.json`, 'creates a JSON-format model of a typescript project')
+    .example(`ts2famix -i "path/to/project/**/*.ts" -o JSONModels/projectName.json`, 'Creates a JSON-format Famix model of typescript files.')
+    .example(`ts2famix -i path/to/tsconfig.json -o JSONModels/projectName.json`, 'Creates a JSON-format model of a typescript project.')
     .alias('i', 'input')
     .nargs('i', 1)
     .alias('o', 'output')
     .nargs('o', 1)
     .demandOption('input').demandOption('output').parseSync();
 
-const paths = new Array<string>();
-paths.push(argv.input as string);
+const importer = new Importer();
+let famixRep: FamixRepository;
+
+if ((argv.input as string).endsWith('tsconfig.json')) {
+    const tsConfigFilePath = argv.input as string;
+    const project = new Project({
+        tsConfigFilePath
+      }); 
+    famixRep = importer.famixRepFromProject(project);
+} else {
+    const paths = new Array<string>();
+    paths.push(argv.input as string);
+    famixRep = importer.famixRepFromPaths(paths);
+}
 
-const famixRep = importer.famixRepFromPaths(paths);
 const jsonOutput = famixRep.getJSON();
 const jsonFilePath = argv.output as string;