ts2famix 1.4.1 → 2.0.1

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

@@ -1,216 +1,238 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FamixRepository = void 0;
-const famix_1 = require("./model/famix");
+import { FamixBaseElement } from "./famix_base_element";
+import { Class, Interface, Variable, Method, ArrowFunction, Function as FamixFunctionEntity, Type, NamedEntity, ScriptEntity, Module, SourceLanguage } from "./model/famix";
+import * as Famix from "./model/famix";
+import { TSMorphObjectType } from "../../famix_functions/EntityDictionary";
 /**
  * This class is used to store all Famix elements
  */
-class FamixRepository {
+export class FamixRepository {
+    private elements = new Set<FamixBaseElement>(); // All Famix elements
+    private famixClasses = new Set<Class>(); // All Famix classes
+    private famixInterfaces = new Set<Interface>(); // All Famix interfaces
+    private famixModules = new Set<Module>(); // All Famix namespaces
+    private famixMethods = new Set<Method>(); // All Famix methods
+    private famixVariables = new Set<Variable>(); // All Famix variables
+    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>();
+    private tsMorphObjectMap = new Map<TSMorphObjectType, Famix.Entity>(); // TODO: add this map to have two-way mapping between Famix and TS Morph objects
+    
     constructor() {
-        this.elements = new Set(); // All Famix elements
-        this.famixClasses = new Set(); // All Famix classes
-        this.famixInterfaces = new Set(); // All Famix interfaces
-        this.famixNamespaces = new Set(); // All Famix namespaces
-        this.famixMethods = new Set(); // All Famix methods
-        this.famixVariables = new Set(); // All Famix variables
-        this.famixFunctions = new Set(); // All Famix functions
-        this.famixFiles = new Set(); // All Famix files
-        this.idCounter = 1; // Id counter
-        this.absolutePath = "";
-        this.fmxElementObjectMap = new Map();
-        this.addElement(new famix_1.SourceLanguage()); // add the source language entity (TypeScript)
-    }
-    setFmxElementObjectMap(fmxElementObjectMap) {
+        this.addElement(new SourceLanguage());  // add the source language entity (TypeScript)
+    }
+
+    public setFmxElementObjectMap(fmxElementObjectMap: Map<Famix.Entity, TSMorphObjectType>) {
         this.fmxElementObjectMap = fmxElementObjectMap;
     }
-    getFmxElementObjectMap() {
+
+    public getFmxElementObjectMap() {
         return this.fmxElementObjectMap;
     }
-    getAbsolutePath() {
+
+    public getAbsolutePath(): string {
         return this.absolutePath;
     }
-    setAbsolutePath(path) {
+
+    public setAbsolutePath(path: string) {
         this.absolutePath = path;
     }
+
     /**
      * Gets a Famix entity by id
      * @param id An id of a Famix entity
      * @returns The Famix entity corresponding to the id or undefined if it doesn't exist
      */
-    getFamixEntityById(id) {
+    public getFamixEntityById(id: number): FamixBaseElement | undefined {
         const entity = Array.from(this.elements.values()).find(e => e.id === id);
         return entity;
     }
+
     /**
      * Gets a Famix entity by fully qualified name
      * @param fullyQualifiedName A fully qualified name
      * @returns The Famix entity corresponding to the fully qualified name or undefined if it doesn't exist
      */
-    getFamixEntityByFullyQualifiedName(fullyQualifiedName) {
-        const allEntities = Array.from(this.elements.values()).filter(e => e instanceof famix_1.NamedEntity);
-        const entity = allEntities.find(e => e.getFullyQualifiedName() === fullyQualifiedName);
+    public getFamixEntityByFullyQualifiedName(fullyQualifiedName: string): FamixBaseElement | undefined {
+        const allEntities = Array.from(this.elements.values()).filter(e => e instanceof NamedEntity) as Array<NamedEntity>;
+        const entity = allEntities.find(e => e.fullyQualifiedName === fullyQualifiedName);
         return entity;
     }
-    export(arg0) {
+
+    export(arg0: { format: string; }) {
         if (arg0.format === "json") {
             return this.getJSON();
-        }
-        else {
+        } else {
             throw new Error("Unsupported format");
         }
     }
+
+
     // Only for tests
+
     /**
      * Gets all Famix entities
      * @returns All Famix entities
      */
-    _getAllEntities() {
+    public _getAllEntities(): Set<FamixBaseElement> {
         return new Set(Array.from(this.elements.values()));
     }
+
     /**
      * Gets all Famix entities of a given type
      * @param theType A type of Famix entity
      * @returns All Famix entities of the given type
      */
-    _getAllEntitiesWithType(theType) {
-        return new Set(Array.from(this.elements.values()).filter(e => e.constructor.name === theType));
+    public _getAllEntitiesWithType(theType: string): Set<FamixBaseElement> {
+        return new Set(Array.from(this.elements.values()).filter(e => (e as FamixBaseElement).constructor.name === theType));
     }
+
     /**
      * Gets a Famix class by name
      * @param name A class name
      * @returns The Famix class corresponding to the name or undefined if it doesn't exist
      */
-    _getFamixClass(fullyQualifiedName) {
-        return Array.from(this.famixClasses.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
+    public _getFamixClass(fullyQualifiedName: string): Class | undefined {
+        return Array.from(this.famixClasses.values()).find(ns => ns.fullyQualifiedName === fullyQualifiedName);
     }
+
     /**
      * Gets a Famix interface by name
      * @param name An interface name
      * @returns The Famix interface corresponding to the name or undefined if it doesn't exist
      */
-    _getFamixInterface(fullyQualifiedName) {
-        return Array.from(this.famixInterfaces.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
+    public _getFamixInterface(fullyQualifiedName: string): Interface | undefined {
+        return Array.from(this.famixInterfaces.values()).find(ns => ns.fullyQualifiedName === fullyQualifiedName);
     }
+
     /**
      * Gets a Famix method by name
      * @param name A method name
      * @returns The Famix method corresponding to the name or undefined if it doesn't exist
      */
-    _getFamixMethod(fullyQualifiedName) {
-        return Array.from(this.famixMethods.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
+    public _getFamixMethod(fullyQualifiedName: string): Method | undefined {
+        return Array.from(this.famixMethods.values()).find(ns => ns.fullyQualifiedName === fullyQualifiedName);
     }
+
     /**
      * Gets a Famix function by name
      * @param name A function name
      * @returns The Famix function corresponding to the name or undefined if it doesn't exist
      */
-    _getFamixFunction(fullyQualifiedName) {
-        return Array.from(this.famixFunctions.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
+    public _getFamixFunction(fullyQualifiedName: string): FamixFunctionEntity | undefined {
+        return Array.from(this.famixFunctions.values()).find(ns => ns.fullyQualifiedName === 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
      */
-    _getFamixVariable(fullyQualifiedName) {
-        return Array.from(this.famixVariables.values()).find(v => v.getFullyQualifiedName() === fullyQualifiedName);
+    public _getFamixVariable(fullyQualifiedName: string): Variable | undefined {
+        return Array.from(this.famixVariables.values()).find(v => v.fullyQualifiedName === fullyQualifiedName);
     }
+
     /**
      * Gets a Famix namespace by name
      * @param name A namespace name
      * @returns The Famix namespace corresponding to the name or undefined if it doesn't exist
      */
-    _getFamixNamespace(fullyQualifiedName) {
-        return Array.from(this.famixNamespaces.values()).find(ns => ns.getFullyQualifiedName() === fullyQualifiedName);
+    public _getFamixModule(fullyQualifiedName: string): Module | undefined {
+        return Array.from(this.famixModules.values()).find(ns => ns.fullyQualifiedName === fullyQualifiedName);
     }
+
     /**
      * Gets all Famix namespaces
      * @returns All Famix namespaces
      */
-    _getFamixNamespaces() {
-        return new Set(Array.from(this.famixNamespaces.values()));
+    public _getFamixModules(): Set<Module> {
+        return new Set(Array.from(this.famixModules.values()));
     }
+
     /**
      * Gets a Famix file by name
      * @param name A file name
      * @returns The Famix file corresponding to the name or undefined if it doesn't exist
      */
-    _getFamixFile(fullyQualifiedName) {
-        return Array.from(this.famixFiles.values()).find(ns => ns.getName() === fullyQualifiedName);
+    public _getFamixFile(fullyQualifiedName: string): ScriptEntity | Module | undefined {
+        return Array.from(this.famixFiles.values()).find(ns => ns.name === fullyQualifiedName);
     }
+
     /**
      * Gets all Famix files
      * @returns All Famix files
      */
-    _getFamixFiles() {
+    public _getFamixFiles(): Set<ScriptEntity | Module> {
         return new Set(Array.from(this.famixFiles.values()));
     }
+
     /**
      * Gets all method names as a set from a class
      * @param className A class name
      * @returns The set of class "className" method names
      */
-    _methodNamesAsSetFromClass(className) {
-        const theClass = this._getFamixClass(className);
-        return new Set(Array.from(theClass.getMethods()).map(m => m.getName()));
+    public _methodNamesAsSetFromClass(className: string): Set<string> {
+        const theClass = this._getFamixClass(className) as Class;
+        return new Set(Array.from(theClass.methods).map(m => m.name));
     }
+
     /**
      * Gets all method parents as a set from a class
      * @param className A class name
      * @returns The set of class "className" method parents
      */
-    _methodParentsAsSetFromClass(className) {
-        const theClass = this._getFamixClass(className);
-        return new Set(Array.from(theClass.getMethods()).map(m => m.getParentEntity()));
+    public _methodParentsAsSetFromClass(className: string): Set<Type> {
+        const theClass = this._getFamixClass(className) as Class;
+        return new Set(Array.from(theClass.methods).map(m => m.parentEntity));
     }
+
     /**
      * Gets the map of Famix element ids and their Famix element from a JSON model
      * @param model A JSON model
      * @returns The map of Famix element ids and their Famix element from the JSON model
      */
-    _initMapFromModel(model) {
-        const parsedModel = JSON.parse(model);
-        const idToElementMap = new Map();
+    public _initMapFromModel(model: string): Map<number, unknown> {
+        const parsedModel: Array<FamixBaseElement> = JSON.parse(model);
+        const idToElementMap: Map<number, unknown> = new Map();
         parsedModel.forEach(element => {
             idToElementMap.set(element.id, element);
         });
         return idToElementMap;
     }
+
+
     /**
      * Adds a Famix element to the repository
      * @param element A Famix element
      */
-    addElement(element) {
-        if (element instanceof famix_1.Class) {
+    public addElement(element: FamixBaseElement): void {
+        if (element instanceof Class) {
             this.famixClasses.add(element);
-        }
-        else if (element instanceof famix_1.Interface) {
+        } else if (element instanceof Interface) {
             this.famixInterfaces.add(element);
-        }
-        else if (element instanceof famix_1.Namespace) {
-            this.famixNamespaces.add(element);
-        }
-        else if (element instanceof famix_1.Variable) {
+        } else if (element instanceof Module) {
+            this.famixModules.add(element);
+        } else if (element instanceof Variable) {
             this.famixVariables.add(element);
-        }
-        else if (element instanceof famix_1.Method) {
+        } else if (element instanceof Method) {
             this.famixMethods.add(element);
-        }
-        else if (element instanceof famix_1.Function) {
+        } else if (element instanceof FamixFunctionEntity || element instanceof ArrowFunction) {
             this.famixFunctions.add(element);
-        }
-        else if (element instanceof famix_1.ScriptEntity || element instanceof famix_1.Module) {
+        } else if (element instanceof ScriptEntity || element instanceof Module) {
             this.famixFiles.add(element);
         }
         this.elements.add(element);
         element.id = this.idCounter;
         this.idCounter++;
     }
+
     /**
      * Gets a JSON representation of the repository
      * @returns A JSON representation of the repository
      */
-    getJSON() {
+    public getJSON(): string {
         let ret = "[";
         for (const element of Array.from(this.elements.values())) {
             ret = ret + element.getJSON() + ",";
@@ -219,4 +241,3 @@ class FamixRepository {
         return ret + "]";
     }
 }
-exports.FamixRepository = FamixRepository;

package/src/lib/famix/model/famix/access.ts

@@ -0,0 +1,50 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { StructuralEntity } from "./structural_entity";
+import { ContainerEntity } from "./container_entity";
+import { Entity } from "./entity";
+
+export class Access extends Entity {
+
+    private _accessor!: ContainerEntity;
+    private _variable!: StructuralEntity;
+    private _isWrite!: boolean;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Access", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("accessor", this.accessor);
+        exporter.addProperty("variable", this.variable);
+        exporter.addProperty("isWrite", this.isWrite);
+    }
+
+    get accessor(): ContainerEntity {
+        return this._accessor;
+    }
+
+    set accessor(accessor: ContainerEntity) {
+        this._accessor = accessor;
+        accessor.addAccess(this);
+    }
+
+    get variable(): StructuralEntity {
+        return this._variable;
+    }
+
+    set variable(variable: StructuralEntity) {
+        this._variable = variable;
+        variable.addIncomingAccess(this);
+    }
+
+    get isWrite(): boolean {
+        return this._isWrite;
+    }
+
+    set isWrite(isWrite: boolean) {
+        this._isWrite = isWrite;
+    }
+}

package/src/lib/famix/model/famix/alias.ts

@@ -0,0 +1,39 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { NamedEntity } from "./named_entity";
+import { Type } from "./type";
+
+export class Alias extends NamedEntity {
+
+    private _parentEntity!: NamedEntity;
+    private _aliasedEntity!: Type;
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Alias", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("parentType", this.parentEntity);
+        exporter.addProperty("aliasedEntity", this.aliasedEntity);
+    }
+
+    get parentEntity(): NamedEntity {
+        return this._parentEntity;
+    }
+
+    set parentEntity(parentEntity: NamedEntity) {
+        this._parentEntity = parentEntity;
+        parentEntity.addAlias(this);
+    }
+
+    get aliasedEntity(): Type {
+        return this._aliasedEntity;
+    }
+
+    set aliasedEntity(aliasedEntity: Type) {
+        this._aliasedEntity = aliasedEntity;
+        aliasedEntity.addTypeAlias(this);
+    }
+}

package/src/lib/famix/{src/model/famix/implicit_variable.ts → model/famix/arrow_function.ts}

@@ -1,10 +1,10 @@
 import { FamixJSONExporter } from "../../famix_JSON_exporter";
-import { Variable } from "./variable";
+import { BehavioralEntity } from "./behavioral_entity";
 
-export class ImplicitVariable extends Variable {
+export class ArrowFunction extends BehavioralEntity {
 
   public getJSON(): string {
-    const json: FamixJSONExporter = new FamixJSONExporter("ImplicitVariable", this);
+    const json: FamixJSONExporter = new FamixJSONExporter("ArrowFunction", this);
     this.addPropertiesToExporter(json);
     return json.getJSON();
   }

package/src/lib/famix/model/famix/behavioral_entity.ts

@@ -0,0 +1,97 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { ContainerEntity } from "./container_entity";
+import { Parameter } from "./parameter";
+import { Invocation } from "./invocation";
+import { ParameterType } from "./parameter_type";
+
+export class BehavioralEntity extends ContainerEntity {
+
+    private _signature!: string;
+    private _parameters: Set<Parameter> = new Set();
+
+    public addParameter(parameter: Parameter): void {
+        if (!this._parameters.has(parameter)) {
+            this._parameters.add(parameter);
+            parameter.parentEntity = this;
+        }
+    }
+
+    private _numberOfParameters!: number;
+    private _incomingInvocations: Set<Invocation> = new Set();
+
+    public addIncomingInvocation(incomingInvocation: Invocation): void {
+        if (!this._incomingInvocations.has(incomingInvocation)) {
+            this._incomingInvocations.add(incomingInvocation);
+            incomingInvocation.addCandidate(this);
+        }
+    }
+
+    private _declaredType!: Type;
+    private _genericParameters: Set<ParameterType> = new Set();
+
+    public addGenericParameter(genericParameter: ParameterType): void {
+        if (!this._genericParameters.has(genericParameter)) {
+            this._genericParameters.add(genericParameter);
+            genericParameter.parentGeneric = this;
+        }
+    }
+
+    clearGenericParameters(): void {
+        this._genericParameters.clear();
+    }
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("BehavioralEntity", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("signature", this.signature);
+        exporter.addProperty("parameters", this.parameters);
+        exporter.addProperty("numberOfParameters", this.numberOfParameters);
+        exporter.addProperty("incomingInvocations", this.incomingInvocations);
+        exporter.addProperty("declaredType", this.declaredType);
+        /* don't add the property here, since it doesn't apply to all subclasses */
+        //    exporter.addProperty("genericParameters", this.getGenericParameters());
+    }
+
+    get signature(): string {
+        return this._signature;
+    }
+
+    set signature(signature: string) {
+        this._signature = signature;
+    }
+
+    get parameters(): Set<Parameter> {
+        return this._parameters;
+    }
+
+    get numberOfParameters(): number {
+        return this._numberOfParameters;
+    }
+
+    set numberOfParameters(numberOfParameters: number) {
+        this._numberOfParameters = numberOfParameters;
+    }
+
+    get incomingInvocations(): Set<Invocation> {
+        return this._incomingInvocations;
+    }
+
+    get declaredType(): Type {
+        return this._declaredType;
+    }
+
+    set declaredType(declaredType: Type) {
+        this._declaredType = declaredType;
+        declaredType.addBehavioralEntityWithDeclaredType(this);
+    }
+
+    get genericParameters(): Set<ParameterType> {
+        return this._genericParameters;
+    }
+}

package/src/lib/famix/model/famix/class.ts

@@ -0,0 +1,85 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { Type } from "./type";
+import { Method } from "./method";
+import { Property } from "./property";
+import { Inheritance } from "./inheritance";
+
+export class Class extends Type {
+
+    private _isAbstract!: boolean;
+    private _properties: Set<Property> = new Set();
+
+    public addProperty(property: Property): void {
+        if (!this._properties.has(property)) {
+            this._properties.add(property);
+            property.parentEntity = this;
+        }
+    }
+
+    private _methods: Set<Method> = new Set();
+
+    public addMethod(method: Method): void {
+        if (!this._methods.has(method)) {
+            this._methods.add(method);
+            method.parentEntity = this;
+        }
+    }
+
+    private _superInheritances: Set<Inheritance> = new Set();
+
+    public addSuperInheritance(superInheritance: Inheritance): void {
+        if (!this._superInheritances.has(superInheritance)) {
+            this._superInheritances.add(superInheritance);
+            superInheritance.subclass = this;
+        }
+    }
+
+    private _subInheritances: Set<Inheritance> = new Set();
+
+    public addSubInheritance(subInheritance: Inheritance): void {
+        if (!this._subInheritances.has(subInheritance)) {
+            this._subInheritances.add(subInheritance);
+            subInheritance.superclass = this;
+        }
+    }
+
+
+    public getJSON(): string {
+        const json: FamixJSONExporter = new FamixJSONExporter("Class", this);
+        this.addPropertiesToExporter(json);
+        return json.getJSON();
+    }
+
+    public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+        super.addPropertiesToExporter(exporter);
+        exporter.addProperty("isAbstract", this.isAbstract);
+        exporter.addProperty("attributes", this.properties); // Moose (10) codes them as attributes
+        exporter.addProperty("methods", this.methods);
+        exporter.addProperty("superInheritances", this.superInheritances);
+        exporter.addProperty("subInheritances", this.subInheritances);
+    }
+
+    get isAbstract(): boolean {
+        return this._isAbstract;
+    }
+
+    set isAbstract(isAbstract: boolean) {
+        this._isAbstract = isAbstract;
+    }
+
+    get properties(): Set<Property> {
+        return this._properties;
+    }
+
+    get methods(): Set<Method> {
+        return this._methods;
+    }
+
+    get superInheritances(): Set<Inheritance> {
+        return this._superInheritances;
+    }
+
+    get subInheritances(): Set<Inheritance> {
+        return this._subInheritances;
+    }
+}

package/src/lib/famix/model/famix/comment.ts

@@ -0,0 +1,47 @@
+import { FamixJSONExporter } from "../../famix_JSON_exporter";
+import { SourcedEntity } from "./sourced_entity";
+
+export class Comment extends SourcedEntity {
+
+  private _isJSDoc!: boolean;
+  private _container!: SourcedEntity;
+  private _content!: string;
+
+  public getJSON(): string {
+    const json: FamixJSONExporter = new FamixJSONExporter("Comment", this);
+    this.addPropertiesToExporter(json);
+    return json.getJSON();
+  }
+
+  public addPropertiesToExporter(exporter: FamixJSONExporter): void {
+    super.addPropertiesToExporter(exporter);
+    exporter.addProperty("isJSDoc", this.isJSDoc);
+    exporter.addProperty("commentedEntity", this.container);
+    exporter.addProperty("content", this.content);
+  }
+
+    get isJSDoc(): boolean {
+        return this._isJSDoc;
+    }
+
+    set isJSDoc(isJSDoc: boolean) {
+        this._isJSDoc = isJSDoc;
+    }
+
+    get container(): SourcedEntity {
+        return this._container;
+    }
+
+    set container(container: SourcedEntity) {
+        this._container = container;
+        container.addComment(this);
+    }
+
+    get content(): string {
+        return this._content;
+    }
+
+    set content(content: string) {
+        this._content = content;
+    }
+}