ts2famix 1.3.1 → 1.4.1

package/src/famix_functions/helpers_creation.ts

@@ -0,0 +1,77 @@
+import * as Famix from "../lib/famix/src/model/famix";
+import { logger } from "../analyze";
+import { ConstructorDeclaration, Identifier, FunctionDeclaration, MethodDeclaration, MethodSignature, PropertyDeclaration, PropertySignature, VariableDeclaration, ParameterDeclaration, GetAccessorDeclaration, SetAccessorDeclaration, EnumMember, TypeAliasDeclaration, Node, SyntaxKind, FunctionExpression } from "ts-morph";
+
+interface SearchParameters {
+    searchArray: string[];
+    targetArray: string[];
+    start?: number;
+}
+
+/**
+ * This function works like indexOf, but it works with arrays of grapheme clusters.
+ * @param targetArray
+ */
+export function indexOfSplitArray(params: SearchParameters): number {
+    const {searchArray, targetArray, start = 0} = params;
+    for (let i = start; i <= searchArray.length - targetArray.length; i++) {
+        let found = true;
+        for (let j = 0; j < targetArray.length; j++) {
+            if (searchArray[i + j] !== targetArray[j]) {
+                found = false;
+                break;
+            }
+        }
+        if (found) {
+            return i; // Return the index where the target array was found
+        }
+    }
+    return -1; // Return -1 if the target array was not found in the search array
+}
+
+export function getSubTypeName(fmxNamedEntity: Famix.NamedEntity) {
+    const name = fmxNamedEntity instanceof Famix.Class ? 'Class' :
+        fmxNamedEntity instanceof Famix.Interface ? 'Interface' :
+            fmxNamedEntity instanceof Famix.Function ? 'Function' :
+                fmxNamedEntity instanceof Famix.Enum ? 'Enum' :
+                    fmxNamedEntity instanceof Famix.EnumValue ? 'EnumValue' :
+                        fmxNamedEntity instanceof Famix.Alias ? 'Alias' :
+                            fmxNamedEntity instanceof Famix.Variable ? 'Variable' :
+                                fmxNamedEntity instanceof Famix.Type ? 'Type' :
+                                    fmxNamedEntity instanceof Famix.Method ? 'Method' :
+                                        fmxNamedEntity instanceof Famix.Decorator ? 'Decorator' :
+                                            fmxNamedEntity instanceof Famix.Accessor ? 'Accessor' :
+                                                fmxNamedEntity instanceof Famix.Parameter ? 'Parameter' :
+                                                    fmxNamedEntity instanceof Famix.Property ? 'Property' :
+                                                        'NamedEntity';
+    logger.debug(`${fmxNamedEntity.getName()} is of type ${name}`);
+    return name;
+}
+
+/**
+ * Gets the signature of a method or a function
+ * @param text A method or a function source code
+ * @returns The signature of the method or the function
+ */
+export function computeSignature(text: string): string {
+    const endSignatureText = text.indexOf("{");
+    return text.substring(0, endSignatureText).trim();
+}
+
+/**
+ * Finds the ancestor of a node
+ * @param node A node
+ * @returns The ancestor of the node
+ */
+export function findAncestor(node: Identifier): Node {
+    return node.getAncestors().find(a => a.getKind() === SyntaxKind.MethodDeclaration || a.getKind() === SyntaxKind.Constructor || a.getKind() === SyntaxKind.FunctionDeclaration || a.getKind() === SyntaxKind.FunctionExpression || a.getKind() === SyntaxKind.ModuleDeclaration || a.getKind() === SyntaxKind.SourceFile || a.getKindName() === "GetAccessor" || a.getKindName() === "SetAccessor" || a.getKind() === SyntaxKind.ClassDeclaration);
+}
+
+/**
+ * Finds the ancestor of a ts-morph element
+ * @param element A ts-morph element
+ * @returns The ancestor of the ts-morph element
+ */
+export function findTypeAncestor(element: TypeAliasDeclaration | PropertyDeclaration | PropertySignature | MethodDeclaration | ConstructorDeclaration | MethodSignature | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression | ParameterDeclaration | VariableDeclaration | EnumMember): Node {
+    return element.getAncestors().find(a => a.getKind() === SyntaxKind.MethodDeclaration || a.getKind() === SyntaxKind.Constructor || a.getKind() === SyntaxKind.MethodSignature || a.getKind() === SyntaxKind.FunctionDeclaration || a.getKind() === SyntaxKind.FunctionExpression || a.getKind() === SyntaxKind.ModuleDeclaration || a.getKind() === SyntaxKind.SourceFile || a.getKindName() === "GetAccessor" || a.getKindName() === "SetAccessor" || a.getKind() === SyntaxKind.ClassDeclaration || a.getKind() === SyntaxKind.InterfaceDeclaration);
+}

package/src/fqn.ts

@@ -1,127 +1,136 @@
 import * as ts from "ts-morph";
+import { entityDictionary } from "./analyze";
+import path from "path";
 
 /**
- * This class is used to get the fully qualified name of a node
+ * Gets the fully qualified name of a node, if it has one
+ * @param node A node
+ * @returns The fully qualified name of the node, or undefined if it doesn't have one
  */
-export class FQNFunctions {
-
-    /**
-     * Gets the fully qualified name of a node, if it has one
-     * @param node A node
-     * @returns The fully qualified name of the node, or undefined if it doesn't have one
-     */
-    public getFQN(node: ts.Node): string {
-        if (node instanceof ts.SourceFile) {
-            return `"${node.getFilePath()}"`;
-        }
+export function getFQN(node: ts.Node): string {
+    const absolutePathProject = entityDictionary.famixRep.getAbsolutePath();
+    
+    if (node instanceof ts.SourceFile) {
+        return entityDictionary.convertToRelativePath(path.normalize(node.getFilePath()), 
+            absolutePathProject).replace(/\\/sg, "/");
+    }
 
-        const symbol = node.getSymbol();
-        if (!symbol) {
-            return undefined;
-        }
+    const symbol = node.getSymbol();
+    if (!symbol) {
+        return undefined;
+    }
 
-        const declarations = symbol.getDeclarations();
-        if (!declarations) {
-            return undefined;
-        }
+    const declarations = symbol.getDeclarations();
+    if (!declarations) {
+        return undefined;
+    }
 
-        const sourceFile = declarations[0].getSourceFile();
-        if (!sourceFile) {
-            return undefined;
-        }
+    const sourceFile = declarations[0].getSourceFile();
+    if (!sourceFile) {
+        return undefined;
+    }
 
-        const sourceFilePath = sourceFile.getFilePath();
-        const sourceFileDirectory = sourceFilePath.substring(0, sourceFilePath.lastIndexOf("/"));
+    const absolutePath = path.normalize(sourceFile.getFilePath());
+    const positionNodeModules = absolutePath.indexOf('node_modules');
+    let pathInProject: string = "";
 
-        const qualifiedNameParts: Array<string> = [];
+    if (positionNodeModules !== -1) {
+        const pathFromNodeModules = absolutePath.substring(positionNodeModules);
+        pathInProject = pathFromNodeModules;
+    } else {
+        pathInProject = entityDictionary.convertToRelativePath(absolutePath, absolutePathProject).replace(/\\/g, "/");     
+    }
 
-        const nodeName = this.getNameOfNode(node);
-        if (nodeName) qualifiedNameParts.push(nodeName);
+    const qualifiedNameParts: Array<string> = [];
 
-        const ancestors = node.getAncestors();
-        ancestors.forEach(a => {
-            const partName = this.getNameOfNode(a);
-            if (partName) qualifiedNameParts.push(partName);
-        });
+    const nodeName = this.getNameOfNode(node);
+    if (nodeName) qualifiedNameParts.push(nodeName);
 
-        if (qualifiedNameParts.length > 0) {
-            return `"${sourceFileDirectory}/${qualifiedNameParts.pop()}".${qualifiedNameParts.reverse().join(".")}`;
-        } 
-        else {
-            return undefined;
-        }
+    const ancestors = node.getAncestors();
+    ancestors.forEach(a => {
+        const partName = this.getNameOfNode(a);
+        if (partName) qualifiedNameParts.push(partName);
+    });
+
+    qualifiedNameParts.pop();
+
+    if (qualifiedNameParts.length > 0) {
+        return `{${pathInProject}}.${qualifiedNameParts.reverse().join(".")}`;
+    } 
+    else {
+        return undefined;
     }
+}
 
-    /**
-     * Gets the name of a node, if it has one
-     * @param a A node
-     * @returns The name of the node, or an empty string if it doesn't have one
-     */
-    private getNameOfNode(a: ts.Node<ts.ts.Node>): string {
-        switch (a.getKind()) {
-            case ts.SyntaxKind.SourceFile:
-                return a.asKind(ts.SyntaxKind.SourceFile)?.getBaseName();
+/**
+ * Gets the name of a node, if it has one
+ * @param a A node
+ * @returns The name of the node, or an empty string if it doesn't have one
+ */
+export function getNameOfNode(a: ts.Node<ts.ts.Node>): string {
+    switch (a.getKind()) {
+        case ts.SyntaxKind.SourceFile:
+            return a.asKind(ts.SyntaxKind.SourceFile)?.getBaseName();
 
-            case ts.SyntaxKind.ModuleDeclaration:
-                return a.asKind(ts.SyntaxKind.ModuleDeclaration)?.getName(); 
+        case ts.SyntaxKind.ModuleDeclaration:
+            return a.asKind(ts.SyntaxKind.ModuleDeclaration)?.getName(); 
 
-            case ts.SyntaxKind.ClassDeclaration:
-                return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName();
+        case ts.SyntaxKind.ClassDeclaration:
+            return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName();
 
-            case ts.SyntaxKind.InterfaceDeclaration:
-                return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName();
+        case ts.SyntaxKind.InterfaceDeclaration:
+            return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName();
                 
-            case ts.SyntaxKind.PropertyDeclaration:
-                return a.asKind(ts.SyntaxKind.PropertyDeclaration)?.getName();    
+        case ts.SyntaxKind.PropertyDeclaration:
+            return a.asKind(ts.SyntaxKind.PropertyDeclaration)?.getName();    
 
-            case ts.SyntaxKind.PropertySignature:
-                return a.asKind(ts.SyntaxKind.PropertySignature)?.getName();    
+        case ts.SyntaxKind.PropertySignature:
+            return a.asKind(ts.SyntaxKind.PropertySignature)?.getName();    
     
-            case ts.SyntaxKind.MethodDeclaration:
-                return a.asKind(ts.SyntaxKind.MethodDeclaration)?.getName();
+        case ts.SyntaxKind.MethodDeclaration:
+            return a.asKind(ts.SyntaxKind.MethodDeclaration)?.getName();
 
-            case ts.SyntaxKind.MethodSignature:
-                return a.asKind(ts.SyntaxKind.MethodSignature)?.getName();   
+        case ts.SyntaxKind.MethodSignature:
+            return a.asKind(ts.SyntaxKind.MethodSignature)?.getName();   
 
-            case ts.SyntaxKind.GetAccessor:
-                return a.asKind(ts.SyntaxKind.GetAccessor)?.getName();
+        case ts.SyntaxKind.GetAccessor:
+            return a.asKind(ts.SyntaxKind.GetAccessor)?.getName();
 
-            case ts.SyntaxKind.SetAccessor:
-                return a.asKind(ts.SyntaxKind.SetAccessor)?.getName();
+        case ts.SyntaxKind.SetAccessor:
+            return a.asKind(ts.SyntaxKind.SetAccessor)?.getName();
     
-            case ts.SyntaxKind.FunctionDeclaration:
-                return a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getName();
+        case ts.SyntaxKind.FunctionDeclaration:
+            return a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getName();
 
-            case ts.SyntaxKind.FunctionExpression:
-                return (a.asKind(ts.SyntaxKind.FunctionExpression)?.getName()) ? a.asKind(ts.SyntaxKind.FunctionExpression)?.getName() : "anonymous";
+        case ts.SyntaxKind.FunctionExpression:
+            return (a.asKind(ts.SyntaxKind.FunctionExpression)?.getName()) ? a.asKind(ts.SyntaxKind.FunctionExpression)?.getName() : "anonymous";
             
-            case ts.SyntaxKind.Parameter:
-                return a.asKind(ts.SyntaxKind.Parameter)?.getName();
+        case ts.SyntaxKind.Parameter:
+            return a.asKind(ts.SyntaxKind.Parameter)?.getName();
                 
-            case ts.SyntaxKind.VariableDeclaration:
-                return a.asKind(ts.SyntaxKind.VariableDeclaration)?.getName();
+        case ts.SyntaxKind.VariableDeclaration:
+            return a.asKind(ts.SyntaxKind.VariableDeclaration)?.getName();
 
-            case ts.SyntaxKind.Decorator:
-                return "@" + a.asKind(ts.SyntaxKind.Decorator)?.getName();    
+        case ts.SyntaxKind.Decorator:
+            return "@" + a.asKind(ts.SyntaxKind.Decorator)?.getName();    
 
-            case ts.SyntaxKind.TypeParameter:
-                return a.asKind(ts.SyntaxKind.TypeParameter)?.getName();
+        case ts.SyntaxKind.TypeParameter:
+            return a.asKind(ts.SyntaxKind.TypeParameter)?.getName();
 
-            case ts.SyntaxKind.EnumDeclaration:
-                return a.asKind(ts.SyntaxKind.EnumDeclaration)?.getName();
+        case ts.SyntaxKind.EnumDeclaration:
+            return a.asKind(ts.SyntaxKind.EnumDeclaration)?.getName();
 
-            case ts.SyntaxKind.EnumMember:
-                return a.asKind(ts.SyntaxKind.EnumMember)?.getName();
+        case ts.SyntaxKind.EnumMember:
+            return a.asKind(ts.SyntaxKind.EnumMember)?.getName();
 
-            case ts.SyntaxKind.TypeAliasDeclaration:
-                return a.asKind(ts.SyntaxKind.TypeAliasDeclaration)?.getName();
+        case ts.SyntaxKind.TypeAliasDeclaration:
+            return a.asKind(ts.SyntaxKind.TypeAliasDeclaration)?.getName();
 
-            case ts.SyntaxKind.Constructor:
-                return "constructor";   
+        case ts.SyntaxKind.Constructor:
+            return "constructor";   
             
-            default:
-                // ancestor hasn't got a useful name
-                return "";
+        default:
+            // ancestor hasn't got a useful name
+            return "";
         }
-    }
-}
+}

package/src/lib/famix/src/famix_base_element.ts

@@ -1,18 +1,22 @@
+import { logger } from "../../../analyze";
 import { FamixJSONExporter } from "./famix_JSON_exporter";
-import { FamixRepository } from "./famix_repository";
+// import { FamixRepository } from "./famix_repository";
 
 export abstract class FamixBaseElement {
 
   public id: number;
 
-  constructor(repo: FamixRepository) {
-    repo.addElement(this);
+  // constructor(repo: FamixRepository) {
+  //   repo.addElement(this);
+  // }
+
+  constructor(){
   }
 
   public abstract getJSON(): string;
 
-  // @ts-ignore
-  // tslint:disable-next-line:no-empty
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    logger.debug("addPropertiesToExporter not implemented for " + this.constructor.name + `(${exporter})`);
   }
 }

package/src/lib/famix/src/famix_repository.ts

@@ -1,6 +1,8 @@
 import { FamixBaseElement } from "./famix_base_element";
 import { Class, Interface, Namespace, Variable, Method, Function as FamixFunctionEntity, Type, NamedEntity, ScriptEntity, Module, SourceLanguage } from "./model/famix";
-
+// import { ClassDeclaration, ConstructorDeclaration, FunctionDeclaration, Identifier, InterfaceDeclaration, MethodDeclaration, MethodSignature, ModuleDeclaration, PropertyDeclaration, PropertySignature, SourceFile, TypeParameterDeclaration, VariableDeclaration, ParameterDeclaration, Decorator, GetAccessorDeclaration, SetAccessorDeclaration, ImportSpecifier, CommentRange, EnumDeclaration, EnumMember, TypeAliasDeclaration, FunctionExpression, ExpressionWithTypeArguments, ImportDeclaration, ImportEqualsDeclaration } from "ts-morph";
+import * as Famix from "./model/famix";
+import { TSMorphObjectType } from "../../../famix_functions/EntityDictionary";
 /**
  * This class is used to store all Famix elements
  */
@@ -14,9 +16,27 @@ export class FamixRepository {
   private famixFunctions = new Set<FamixFunctionEntity>(); // All Famix functions
   private famixFiles = new Set<ScriptEntity | Module>(); // All Famix files
   private idCounter = 1; // Id counter
+  private absolutePath: string = "";
+  private fmxElementObjectMap = new Map<Famix.Entity,TSMorphObjectType>();
 
   constructor() {
-    this.addElement(new SourceLanguage(this));  // add the source language entity (TypeScript)
+    this.addElement(new SourceLanguage());  // add the source language entity (TypeScript)
+  }
+
+  public setFmxElementObjectMap(fmxElementObjectMap: Map<Famix.Entity,TSMorphObjectType>){
+    this.fmxElementObjectMap = fmxElementObjectMap;
+  }
+
+  public getFmxElementObjectMap(){
+    return this.fmxElementObjectMap;
+  }
+
+  public getAbsolutePath() : string {
+    return this.absolutePath;
+  }
+
+  public setAbsolutePath( path: string ){
+    this.absolutePath = path;
   }
 
   /**
@@ -43,6 +63,8 @@ export class FamixRepository {
   export(arg0: { format: string; }) {
     if(arg0.format === "json") {
       return this.getJSON();
+    } else {
+      throw new Error("Unsupported format");
     }
   }
 
@@ -63,7 +85,7 @@ export class FamixRepository {
    * @returns All Famix entities of the given type
    */
   public _getAllEntitiesWithType(theType: string): Set<FamixBaseElement> {
-    return new Set(Array.from(this.elements.values()).filter(e => (e as any).constructor.name === theType));
+    return new Set(Array.from(this.elements.values()).filter(e => (e as FamixBaseElement).constructor.name === theType));
   }
 
   /**
@@ -71,8 +93,8 @@ export class FamixRepository {
    * @param name A class name
    * @returns The Famix class corresponding to the name or undefined if it doesn't exist
    */
-  public _getFamixClass(name: string): Class | undefined {
-    return Array.from(this.famixClasses.values()).find(ns => ns.getName() === name);
+  public _getFamixClass(fullyQualifiedName: string): Class | undefined {
+    return Array.from(this.famixClasses.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
   }
 
   /**
@@ -80,8 +102,8 @@ export class FamixRepository {
    * @param name An interface name
    * @returns The Famix interface corresponding to the name or undefined if it doesn't exist
    */
-  public _getFamixInterface(name: string): Interface | undefined {
-    return Array.from(this.famixInterfaces.values()).find(ns => ns.getName() === name);
+  public _getFamixInterface(fullyQualifiedName: string): Interface | undefined {
+    return Array.from(this.famixInterfaces.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
   }
 
   /**
@@ -89,8 +111,8 @@ export class FamixRepository {
    * @param name A method name
    * @returns The Famix method corresponding to the name or undefined if it doesn't exist
    */
-  public _getFamixMethod(name: string): Method | undefined {
-    return Array.from(this.famixMethods.values()).find(ns => ns.getName() === name);
+  public _getFamixMethod(fullyQualifiedName: string): Method | undefined {
+    return Array.from(this.famixMethods.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
   }
 
   /**
@@ -98,18 +120,18 @@ export class FamixRepository {
    * @param name A function name
    * @returns The Famix function corresponding to the name or undefined if it doesn't exist
    */
-  public _getFamixFunction(name: string): FamixFunctionEntity | undefined {
-    return Array.from(this.famixFunctions.values()).find(ns => ns.getName() === name);
+  public _getFamixFunction(fullyQualifiedName: string): FamixFunctionEntity | undefined {
+    return Array.from(this.famixFunctions.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
   }
 
 
-/**
- * Gets a Famix variable by name
- * @param name A variable name
- * @returns The Famix variable corresponding to the name or undefined if it doesn't exist
- */
-  public _getFamixVariable(name: string): Variable | undefined {
-    return Array.from(this.famixVariables.values()).find(v => v.getName() === name);
+  /**
+   * Gets a Famix variable by name
+   * @param name A variable name
+   * @returns The Famix variable corresponding to the name or undefined if it doesn't exist
+   */
+  public _getFamixVariable(fullyQualifiedName: string): Variable | undefined {
+    return Array.from(this.famixVariables.values()).find(v => v.getFullyQualifiedName() === fullyQualifiedName);
   }
 
   /**
@@ -117,8 +139,8 @@ export class FamixRepository {
    * @param name A namespace name
    * @returns The Famix namespace corresponding to the name or undefined if it doesn't exist
    */
-  public _getFamixNamespace(name: string): Namespace | undefined {
-    return Array.from(this.famixNamespaces.values()).find(ns => ns.getName() === name);
+  public _getFamixNamespace(fullyQualifiedName: string): Namespace | undefined {
+    return Array.from(this.famixNamespaces.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
   }
 
   /**
@@ -134,8 +156,8 @@ export class FamixRepository {
    * @param name A file name
    * @returns The Famix file corresponding to the name or undefined if it doesn't exist
    */
-  public _getFamixFile(name: string): ScriptEntity | Module | undefined {
-    return Array.from(this.famixFiles.values()).find(ns => ns.getName() === name);
+  public _getFamixFile(fullyQualifiedName: string): ScriptEntity | Module | undefined {
+    return Array.from(this.famixFiles.values()).find(ns => ns.getName() === fullyQualifiedName);
   }
 
   /**
@@ -172,7 +194,7 @@ export class FamixRepository {
    * @returns The map of Famix element ids and their Famix element from the JSON model
    */
   public _initMapFromModel(model: string): Map<number, unknown> {
-    const parsedModel: Array<any> = JSON.parse(model);
+    const parsedModel: Array<FamixBaseElement> = JSON.parse(model);
     const idToElementMap: Map<number, unknown> = new Map();
     parsedModel.forEach(element => {
         idToElementMap.set(element.id, element);

package/src/lib/ts-complex/cyclomatic-service.ts

@@ -12,12 +12,10 @@ The above copyright notice and this permission notice shall be included in all c
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 */
 
-import { forEachChild, SyntaxKind, createSourceFile } from 'typescript';
+import { forEachChild, isIdentifier, SyntaxKind, createSourceFile, ScriptTarget } from 'typescript';
 import { isFunctionWithBody } from 'tsutils';
 import { existsSync, readFileSync } from 'fs';
 
-const { isIdentifier } = require('typescript');
-
 const getNodeName = (node) => {
   const { name, pos, end } = node;
   const key = name !== undefined && isIdentifier(name) ? name.text : JSON.stringify({ pos, end });
@@ -80,6 +78,6 @@ export const calculate = (filePath) => {
     throw new Error(`File "${filePath}" does not exists`);
   }
   const sourceText = readFileSync(filePath).toString();
-  const source = createSourceFile(filePath, sourceText, isIdentifier.ES2015);
+  const source = createSourceFile(filePath, sourceText, ScriptTarget.ES2015);
   return calculateFromSource(source);
 };

package/src/ts2famix-cli.ts

@@ -37,6 +37,7 @@ if ((argv.input as string).endsWith('tsconfig.json')) {
         tsConfigFilePath
       }); 
     famixRep = importer.famixRepFromProject(project);
+
 } else {
     const paths = new Array<string>();
     paths.push(argv.input as string);

package/dist/analyze_functions/processAccesses.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessAccesses = void 0;
-const analyze_1 = require("../analyze");
-/**
- * This class is used to build a Famix model for the accesses
- */
-class ProcessAccesses {
-    /**
-     * Initializes the ProcessAccesses object
-     * @param famixFunctions FamixFunctions object, it contains all the functions needed to create Famix entities
-     */
-    constructor(famixFunctions) {
-        this.famixFunctions = famixFunctions;
-    }
-    /**
-     * Builds a Famix model for the accesses on the parameters, variables, properties and enum members of the source files
-     * @param accessMap A map of parameters, variables, properties and enum members with their id
-     */
-    processAccesses(accessMap) {
-        analyze_1.logger.debug(`processAccesses: Creating accesses:`);
-        accessMap.forEach((v, id) => {
-            analyze_1.logger.debug(`processAccesses: Accesses to ${v.getName()}`);
-            try {
-                const temp_nodes = v.findReferencesAsNodes();
-                temp_nodes.forEach(node => this.processNodeForAccesses(node, id));
-            }
-            catch (error) {
-                analyze_1.logger.error(`> WARNING: got exception ${error}. Continuing...`);
-            }
-        });
-    }
-    /**
-     * Builds a Famix model for an access on a parameter, variable, property or enum member
-     * @param n A node
-     * @param id An id of a parameter, a variable, a property or an enum member
-     */
-    processNodeForAccesses(n, id) {
-        try {
-            // sometimes node's first ancestor is a PropertyDeclaration, which is not an access
-            // see https://github.com/fuhrmanator/FamixTypeScriptImporter/issues/9
-            // check for a node whose first ancestor is a property declaration and bail?
-            // This may be a bug in ts-morph?
-            if (n.getFirstAncestorOrThrow().getKindName() === "PropertyDeclaration") {
-                analyze_1.logger.debug(`processNodeForAccesses: node kind: ${n.getKindName()}, ${n.getText()}, (${n.getType().getText()})'s first ancestor is a PropertyDeclaration. Skipping...`);
-                return;
-            }
-            this.famixFunctions.createFamixAccess(n, id);
-            analyze_1.logger.debug(`processNodeForAccesses: node kind: ${n.getKindName()}, ${n.getText()}, (${n.getType().getText()})`);
-        }
-        catch (error) {
-            analyze_1.logger.error(`> WARNING: got exception ${error}. ScopeDeclaration invalid for ${n.getSymbol().getFullyQualifiedName()}. Continuing...`);
-        }
-    }
-}
-exports.ProcessAccesses = ProcessAccesses;