ts2famix 1.4.1 → 2.0.1

package/src/famix_functions/helpers_creation.ts

@@ -1,6 +1,7 @@
-import * as Famix from "../lib/famix/src/model/famix";
+import * as Famix from "../lib/famix/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";
+import { TypeDeclaration } from "./EntityDictionary";
 
 interface SearchParameters {
     searchArray: string[];
@@ -44,7 +45,7 @@ export function getSubTypeName(fmxNamedEntity: Famix.NamedEntity) {
                                                 fmxNamedEntity instanceof Famix.Parameter ? 'Parameter' :
                                                     fmxNamedEntity instanceof Famix.Property ? 'Property' :
                                                         'NamedEntity';
-    logger.debug(`${fmxNamedEntity.getName()} is of type ${name}`);
+    logger.debug(`${fmxNamedEntity.name} is of type ${name}`);
     return name;
 }
 
@@ -64,7 +65,21 @@ export function computeSignature(text: string): string {
  * @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);
+    let ancestor: Node | undefined;
+    ancestor = 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);
+    if (!ancestor) {
+        throw new Error(`Ancestor not found for ${node.getText()}`);
+    }
+    return ancestor
 }
 
 /**
@@ -72,6 +87,49 @@ export function findAncestor(node: Identifier): Node {
  * @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);
-}
+export function findTypeAncestor(element: TypeDeclaration): Node {
+    let ancestor: Node | undefined;
+    ancestor = 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);
+    if (!ancestor) {
+        throw new Error(`Type ancestor not found for ${element.getKindName()}`);
+    }
+    return ancestor;
+}
+
+export function arraysAreEqual(array1: string[], array2: string[]): boolean {
+    if (array1 && array2 ) {
+        return array1.length === array2.length && array1.every((value, index) => value === array2[index]);
+    } else {
+        return false;
+    }
+}
+
+export function replaceLastBetweenTags(input: string, replacement: string): string {
+    const lastTagIndex = input.lastIndexOf('<');
+    
+    if (lastTagIndex === -1) {
+        return input; // Return the original string if no tags are found
+    }
+
+    const closingTagIndex = input.indexOf('>', lastTagIndex);
+    
+    if (closingTagIndex === -1) {
+        return input; // Return the original string if no closing tag is found
+    }
+
+    const beforeTag = input.substring(0, lastTagIndex + 1); // Include '<'
+    const afterTag = input.substring(closingTagIndex); // Include '>'
+
+    return beforeTag + replacement + afterTag;
+}

package/src/fqn.ts

@@ -1,65 +1,92 @@
-import * as ts from "ts-morph";
-import { entityDictionary } from "./analyze";
+import { ArrowFunction, CallExpression, ClassDeclaration, ClassExpression, ConstructorDeclaration, Decorator, EnumDeclaration, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, ImportDeclaration, ImportEqualsDeclaration, InterfaceDeclaration, MethodDeclaration, MethodSignature, ModuleDeclaration, Node, PropertyDeclaration, SetAccessorDeclaration, SourceFile, SyntaxKind, TypeParameterDeclaration, VariableDeclaration } from "ts-morph";
+import { entityDictionary, logger } from "./analyze";
 import path from "path";
+import { TypeDeclaration } from "./famix_functions/EntityDictionary";
 
-/**
- * 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 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, "/");
-    }
+type FQNNode = SourceFile | VariableDeclaration | ArrowFunction | Identifier | MethodDeclaration | MethodSignature | FunctionDeclaration | FunctionExpression | PropertyDeclaration | TypeDeclaration | EnumDeclaration | ImportDeclaration | ImportEqualsDeclaration | CallExpression | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | TypeParameterDeclaration | ClassDeclaration | InterfaceDeclaration | Decorator | ModuleDeclaration;
 
-    const symbol = node.getSymbol();
-    if (!symbol) {
-        return undefined;
-    }
+function isFQNNode(node: Node): node is FQNNode {
+    return Node.isVariableDeclaration(node) || Node.isArrowFunction(node) || Node.isIdentifier(node) || Node.isMethodDeclaration(node) || Node.isClassDeclaration(node) || Node.isClassExpression(node) || Node.isDecorator(node) || Node.isModuleDeclaration(node) || Node.isCallExpression(node);
 
-    const declarations = symbol.getDeclarations();
-    if (!declarations) {
-        return undefined;
-    }
+}
+
+export function getFQN(node: FQNNode | Node): string {
+    const absolutePathProject = entityDictionary.famixRep.getAbsolutePath();
 
-    const sourceFile = declarations[0].getSourceFile();
-    if (!sourceFile) {
-        return undefined;
+    const sourceFile = node.getSourceFile();
+    let parts: string[] = [];
+    let currentNode: Node | undefined = node;
+
+    while (currentNode && !Node.isSourceFile(currentNode)) {
+        const { line, column } = sourceFile.getLineAndColumnAtPos(currentNode.getStart());
+        const lc = `${line}:${column}`;
+        if (Node.isClassDeclaration(currentNode) || 
+            Node.isClassExpression(currentNode) || 
+            Node.isInterfaceDeclaration(currentNode) ||
+            Node.isFunctionDeclaration(currentNode) || 
+            Node.isMethodDeclaration(currentNode) || 
+            Node.isModuleDeclaration(currentNode) || 
+            Node.isVariableDeclaration(currentNode) || 
+            Node.isGetAccessorDeclaration(currentNode) ||
+            Node.isSetAccessorDeclaration(currentNode) ||
+            Node.isIdentifier(currentNode)) {
+            let name = Node.isIdentifier(currentNode) ? currentNode.getText() 
+                : getNameOfNode(currentNode) /* currentNode.getName() */ || 'Unnamed_' + currentNode.getKindName() + `(${lc})`;
+            parts.unshift(name);
+        } else if (Node.isArrowFunction(currentNode) || 
+                   Node.isBlock(currentNode) || 
+                   Node.isForInStatement(currentNode) || 
+                   Node.isForOfStatement(currentNode) || 
+                   Node.isForStatement(currentNode) || 
+                   Node.isCatchClause(currentNode)) {
+            parts.unshift(`${currentNode.getKindName()}(${lc})`);
+        } else if (Node.isConstructorDeclaration(currentNode)) {
+            parts.unshift(`constructor`);
+        } else {
+            // For other kinds, you might want to handle them specifically or ignore
+            //console.log(`Ignoring node kind: ${currentNode.getKindName()}`);
+        }
+        currentNode = currentNode.getParent();
     }
 
-    const absolutePath = path.normalize(sourceFile.getFilePath());
-    const positionNodeModules = absolutePath.indexOf('node_modules');
-    let pathInProject: string = "";
 
-    if (positionNodeModules !== -1) {
-        const pathFromNodeModules = absolutePath.substring(positionNodeModules);
-        pathInProject = pathFromNodeModules;
-    } else {
-        pathInProject = entityDictionary.convertToRelativePath(absolutePath, absolutePathProject).replace(/\\/g, "/");     
-    }
 
-    const qualifiedNameParts: Array<string> = [];
+    // Prepend the relative path of the source file
+    const relativePath = entityDictionary.convertToRelativePath(
+        path.normalize(sourceFile.getFilePath()), 
+                       absolutePathProject).replace(/\\/sg, "/");
+    parts.unshift(`{${relativePath}}`);
+    const fqn = parts.join(".") + `[${node.getKindName()}]`;  // disambiguate
 
-    const nodeName = this.getNameOfNode(node);
-    if (nodeName) qualifiedNameParts.push(nodeName);
+    logger.debug(fqn);
+    return fqn;
+}
 
-    const ancestors = node.getAncestors();
-    ancestors.forEach(a => {
-        const partName = this.getNameOfNode(a);
-        if (partName) qualifiedNameParts.push(partName);
-    });
 
-    qualifiedNameParts.pop();
+export function getUniqueFQN(node: Node): string | undefined {
+    const absolutePathProject = entityDictionary.famixRep.getAbsolutePath();
+    let parts: string[] = [];
 
-    if (qualifiedNameParts.length > 0) {
-        return `{${pathInProject}}.${qualifiedNameParts.reverse().join(".")}`;
-    } 
-    else {
-        return undefined;
+    if (node instanceof SourceFile) {
+        return entityDictionary.convertToRelativePath(path.normalize(node.getFilePath()), absolutePathProject).replace(/\\/g, "/");
     }
+
+    let currentNode: Node | undefined = node;
+    while (currentNode) {
+        if (Node.isSourceFile(currentNode)) {
+            const relativePath = entityDictionary.convertToRelativePath(path.normalize(currentNode.getFilePath()), absolutePathProject).replace(/\\/g, "/");
+            parts.unshift(relativePath); // Add file path at the start
+            break;
+        } else if (currentNode.getSymbol()) {
+            const name = currentNode.getSymbol()!.getName();
+            // For anonymous nodes, use kind and position as unique identifiers
+            const identifier = name !== "__computed" ? name : `${currentNode.getKindName()}_${currentNode.getStartLinePos()}`;
+            parts.unshift(identifier);
+        }
+        currentNode = currentNode.getParent();
+    }
+
+    return parts.join("::");
 }
 
 /**
@@ -67,70 +94,116 @@ export function getFQN(node: ts.Node): string {
  * @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 {
+export function getNameOfNode(a: 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.ClassDeclaration:
-            return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName();
-
-        case ts.SyntaxKind.InterfaceDeclaration:
-            return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName();
+        case SyntaxKind.SourceFile:
+            return a.asKind(SyntaxKind.SourceFile)!.getBaseName();
+
+        case SyntaxKind.ModuleDeclaration:
+            return a.asKind(SyntaxKind.ModuleDeclaration)!.getName(); 
+
+        case SyntaxKind.ClassDeclaration:
+            const cKind = a.asKind(SyntaxKind.ClassDeclaration);
+            if (cKind && cKind.getTypeParameters().length > 0) {
+                return cKind.getName() + getParameters(a);
+            } else {
+                return cKind?.getName() || "";
+            }
+
+        case SyntaxKind.InterfaceDeclaration:
+            const iKind = a.asKind(SyntaxKind.InterfaceDeclaration);
+            if (iKind && iKind.getTypeParameters().length > 0) {
+                return iKind.getName() + getParameters(a);
+            } else {
+                return iKind?.getName() || "";
+            }
                 
-        case ts.SyntaxKind.PropertyDeclaration:
-            return a.asKind(ts.SyntaxKind.PropertyDeclaration)?.getName();    
+        case SyntaxKind.PropertyDeclaration:
+            return a.asKind(SyntaxKind.PropertyDeclaration)!.getName();    
 
-        case ts.SyntaxKind.PropertySignature:
-            return a.asKind(ts.SyntaxKind.PropertySignature)?.getName();    
+        case SyntaxKind.PropertySignature:
+            return a.asKind(SyntaxKind.PropertySignature)!.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.GetAccessor:
-            return a.asKind(ts.SyntaxKind.GetAccessor)?.getName();
-
-        case ts.SyntaxKind.SetAccessor:
-            return a.asKind(ts.SyntaxKind.SetAccessor)?.getName();
+        case SyntaxKind.MethodDeclaration:
+            const mKind = a.asKind(SyntaxKind.MethodDeclaration);
+            if (mKind && mKind.getTypeParameters().length > 0) {
+                return mKind.getName() + getParameters(a);
+            } else {
+                return mKind?.getName() || "";
+            }
+
+        case SyntaxKind.MethodSignature:
+            return a.asKind(SyntaxKind.MethodSignature)!.getName();   
+
+        case SyntaxKind.GetAccessor:
+            return a.asKind(SyntaxKind.GetAccessor)!.getName();
+
+        case SyntaxKind.SetAccessor:
+            return a.asKind(SyntaxKind.SetAccessor)!.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 SyntaxKind.FunctionDeclaration:
+            const fKind = a.asKind(SyntaxKind.FunctionDeclaration);
+            if (fKind && fKind.getTypeParameters().length > 0) {
+                return fKind.getName() + getParameters(a);
+            } else {
+                return fKind?.getName() || "";
+            }
+
+        case SyntaxKind.FunctionExpression:
+            return a.asKind(SyntaxKind.FunctionExpression)?.getName() || "anonymous";
             
-        case ts.SyntaxKind.Parameter:
-            return a.asKind(ts.SyntaxKind.Parameter)?.getName();
+        case SyntaxKind.Parameter:
+            return a.asKind(SyntaxKind.Parameter)!.getName();
                 
-        case ts.SyntaxKind.VariableDeclaration:
-            return a.asKind(ts.SyntaxKind.VariableDeclaration)?.getName();
+        case SyntaxKind.VariableDeclaration:
+            return a.asKind(SyntaxKind.VariableDeclaration)!.getName();
 
-        case ts.SyntaxKind.Decorator:
-            return "@" + a.asKind(ts.SyntaxKind.Decorator)?.getName();    
+        case SyntaxKind.Decorator:
+            return "@" + a.asKind(SyntaxKind.Decorator)!.getName();    
 
-        case ts.SyntaxKind.TypeParameter:
-            return a.asKind(ts.SyntaxKind.TypeParameter)?.getName();
+        case SyntaxKind.TypeParameter:
+            return a.asKind(SyntaxKind.TypeParameter)!.getName();
 
-        case ts.SyntaxKind.EnumDeclaration:
-            return a.asKind(ts.SyntaxKind.EnumDeclaration)?.getName();
+        case SyntaxKind.EnumDeclaration:
+            return a.asKind(SyntaxKind.EnumDeclaration)!.getName();
 
-        case ts.SyntaxKind.EnumMember:
-            return a.asKind(ts.SyntaxKind.EnumMember)?.getName();
+        case SyntaxKind.EnumMember:
+            return a.asKind(SyntaxKind.EnumMember)!.getName();
 
-        case ts.SyntaxKind.TypeAliasDeclaration:
-            return a.asKind(ts.SyntaxKind.TypeAliasDeclaration)?.getName();
+        case SyntaxKind.TypeAliasDeclaration:
+            return a.asKind(SyntaxKind.TypeAliasDeclaration)!.getName();
 
-        case ts.SyntaxKind.Constructor:
+        case SyntaxKind.Constructor:
             return "constructor";   
             
         default:
             // ancestor hasn't got a useful name
             return "";
         }
-}
+}
+
+/**
+ * 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 getParameters(a: Node): string {
+    let paramString = "";
+    switch (a.getKind()) {
+        case SyntaxKind.ClassDeclaration:
+            paramString = "<" + a.asKind(SyntaxKind.ClassDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+            break;
+        case SyntaxKind.InterfaceDeclaration:
+            paramString = "<" + a.asKind(SyntaxKind.InterfaceDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+            break;
+        case SyntaxKind.MethodDeclaration:
+            paramString = "<" + a.asKind(SyntaxKind.MethodDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+            break;
+        case SyntaxKind.FunctionDeclaration:
+            paramString = "<" + a.asKind(SyntaxKind.FunctionDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+            break;
+        default:
+            throw new Error(`getParameters called on a node that doesn't have parameters: ${a.getKindName()}`);
+    }
+    return paramString;
+}

package/{dist/lib/famix/src/famix_JSON_exporter.js → src/lib/famix/famix_JSON_exporter.ts}

@@ -1,33 +1,35 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FamixJSONExporter = void 0;
-const famix_base_element_1 = require("./famix_base_element");
+import { FamixBaseElement } from "./famix_base_element";
+
 /**
  * This class is used to export Famix elements to JSON
  */
-class FamixJSONExporter {
+export class FamixJSONExporter {
+
+    private element: FamixBaseElement; // A Famix element to export
+    private bufferArray: any = {}; // A buffer to store the properties of the Famix element
+    private FamixPrefix = "FamixTypeScript"; // Prefix of the Famix element
+
     /**
      * Constructor of the FamixJSONExporter class
      * @param packageClass Name of a Famix class
      * @param element A Famix element to export, this element is an instance of the class named "packageClass"
      */
-    constructor(packageClass, element) {
-        this.bufferArray = {}; // A buffer to store the properties of the Famix element
-        this.FamixPrefix = "FamixTypeScript"; // Prefix of the Famix element
+    constructor(packageClass: string, element: FamixBaseElement) {
         this.element = element;
         this.bufferArray["FM3"] = this.FamixPrefix + "." + packageClass;
         this.bufferArray["id"] = this.element.id;
     }
+
     /**
      * Adds a property to the Famix element
      * @param name Name of the property
      * @param prop A property
      */
-    addProperty(name, prop) {
+    public addProperty(name: string, prop: unknown): void {
         if (prop instanceof Set) {
-            const valueArray = [];
+            const valueArray: Array<unknown> = [];
             for (const value of Array.from(prop.values())) {
-                if (value instanceof famix_base_element_1.FamixBaseElement) {
+                if (value instanceof FamixBaseElement) {
                     valueArray.push({ "ref": value.id });
                 }
                 else {
@@ -36,19 +38,19 @@ class FamixJSONExporter {
             }
             this.bufferArray[name] = valueArray;
         }
-        else if (prop instanceof famix_base_element_1.FamixBaseElement) {
+        else if (prop instanceof FamixBaseElement) {
             this.bufferArray[name] = { "ref": prop.id };
         }
         else if (prop !== undefined && !(prop instanceof Set)) {
             this.bufferArray[name] = prop;
         }
     }
+
     /**
      * Gets a JSON representation of the Famix element
      * @returns A JSON representation of the Famix element
      */
-    getJSON() {
+    public getJSON(): string {
         return JSON.stringify(this.bufferArray);
     }
 }
-exports.FamixJSONExporter = FamixJSONExporter;

package/src/lib/famix/famix_base_element.ts

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