ts2famix 2.0.0 → 2.0.1

package/src/famix_functions/helpers_creation.ts

@@ -1,4 +1,4 @@
-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";
@@ -45,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;
 }
 
@@ -65,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
 }
 
 /**
@@ -74,12 +88,30 @@ export function findAncestor(node: Identifier): Node {
  * @returns The ancestor of the ts-morph element
  */
 export function findTypeAncestor(element: TypeDeclaration): 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);
+    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;
     }
 }
 

package/src/fqn.ts

@@ -1,9 +1,8 @@
-import { ArrowFunction, CallExpression, ClassDeclaration, ClassExpression, ConstructorDeclaration, Decorator, EnumDeclaration, FunctionDeclaration, FunctionExpression, GetAccessorDeclaration, Identifier, ImportDeclaration, ImportEqualsDeclaration, InterfaceDeclaration, MethodDeclaration, MethodSignature, ModuleDeclaration, Node, PropertyDeclaration, SetAccessorDeclaration, SourceFile, ts, TypeParameterDeclaration, VariableDeclaration } from "ts-morph";
+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";
 
-
 type FQNNode = SourceFile | VariableDeclaration | ArrowFunction | Identifier | MethodDeclaration | MethodSignature | FunctionDeclaration | FunctionExpression | PropertyDeclaration | TypeDeclaration | EnumDeclaration | ImportDeclaration | ImportEqualsDeclaration | CallExpression | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | TypeParameterDeclaration | ClassDeclaration | InterfaceDeclaration | Decorator | ModuleDeclaration;
 
 function isFQNNode(node: Node): node is FQNNode {
@@ -72,84 +71,24 @@ export function getUniqueFQN(node: Node): string | undefined {
         return entityDictionary.convertToRelativePath(path.normalize(node.getFilePath()), absolutePathProject).replace(/\\/g, "/");
     }
 
-    while (node) {
-        if (Node.isSourceFile(node)) {
-            const relativePath = 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 (node.getSymbol()) {
-            const name = node.getSymbol()!.getName();
+        } else if (currentNode.getSymbol()) {
+            const name = currentNode.getSymbol()!.getName();
             // For anonymous nodes, use kind and position as unique identifiers
-            const identifier = name !== "__computed" ? name : `${node.getKindName()}_${node.getStartLinePos()}`;
+            const identifier = name !== "__computed" ? name : `${currentNode.getKindName()}_${currentNode.getStartLinePos()}`;
             parts.unshift(identifier);
         }
-        node = node.getParent();
+        currentNode = currentNode.getParent();
     }
 
     return parts.join("::");
 }
 
-
-/**
- * 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 oldGetFQN(node: Node): string {
-    const absolutePathProject = entityDictionary.famixRep.getAbsolutePath();
-    
-    if (node instanceof SourceFile) {
-        return entityDictionary.convertToRelativePath(path.normalize(node.getFilePath()), 
-            absolutePathProject).replace(/\\/sg, "/");
-    }
-
-    const symbol = node.getSymbol();
-    if (!symbol) {
-        return undefined;
-    }
-
-    const declarations = symbol.getDeclarations();
-    if (!declarations) {
-        return undefined;
-    }
-
-    const sourceFile = declarations[0].getSourceFile();
-    if (!sourceFile) {
-        return undefined;
-    }
-
-    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> = [];
-
-    const nodeName = this.getNameOfNode(node);
-    if (nodeName) qualifiedNameParts.push(nodeName);
-
-    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
@@ -157,80 +96,84 @@ export function oldGetFQN(node: Node): string {
  */
 export function getNameOfNode(a: Node): string {
     switch (a.getKind()) {
-        case ts.SyntaxKind.SourceFile:
-            return a.asKind(ts.SyntaxKind.SourceFile)?.getBaseName();
+        case SyntaxKind.SourceFile:
+            return a.asKind(SyntaxKind.SourceFile)!.getBaseName();
 
-        case ts.SyntaxKind.ModuleDeclaration:
-            return a.asKind(ts.SyntaxKind.ModuleDeclaration)?.getName(); 
+        case SyntaxKind.ModuleDeclaration:
+            return a.asKind(SyntaxKind.ModuleDeclaration)!.getName(); 
 
-        case ts.SyntaxKind.ClassDeclaration:
-            if (a.asKind(ts.SyntaxKind.ClassDeclaration).getTypeParameters().length>0){
-                return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName()+getParameters(a);
+        case SyntaxKind.ClassDeclaration:
+            const cKind = a.asKind(SyntaxKind.ClassDeclaration);
+            if (cKind && cKind.getTypeParameters().length > 0) {
+                return cKind.getName() + getParameters(a);
             } else {
-                return a.asKind(ts.SyntaxKind.ClassDeclaration)?.getName();
+                return cKind?.getName() || "";
             }
 
-        case ts.SyntaxKind.InterfaceDeclaration:
-            if (a.asKind(ts.SyntaxKind.InterfaceDeclaration).getTypeParameters().length>0){
-                return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName()+getParameters(a);
+        case SyntaxKind.InterfaceDeclaration:
+            const iKind = a.asKind(SyntaxKind.InterfaceDeclaration);
+            if (iKind && iKind.getTypeParameters().length > 0) {
+                return iKind.getName() + getParameters(a);
             } else {
-                return a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getName();
+                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:
-            if (a.asKind(ts.SyntaxKind.MethodDeclaration).getTypeParameters().length>0){
-                return a.asKind(ts.SyntaxKind.MethodDeclaration)?.getName()+getParameters(a);
+        case SyntaxKind.MethodDeclaration:
+            const mKind = a.asKind(SyntaxKind.MethodDeclaration);
+            if (mKind && mKind.getTypeParameters().length > 0) {
+                return mKind.getName() + getParameters(a);
             } else {
-                return a.asKind(ts.SyntaxKind.MethodDeclaration)?.getName();
+                return mKind?.getName() || "";
             }
 
-        case ts.SyntaxKind.MethodSignature:
-            return a.asKind(ts.SyntaxKind.MethodSignature)?.getName();   
+        case SyntaxKind.MethodSignature:
+            return a.asKind(SyntaxKind.MethodSignature)!.getName();   
 
-        case ts.SyntaxKind.GetAccessor:
-            return a.asKind(ts.SyntaxKind.GetAccessor)?.getName();
+        case SyntaxKind.GetAccessor:
+            return a.asKind(SyntaxKind.GetAccessor)!.getName();
 
-        case ts.SyntaxKind.SetAccessor:
-            return a.asKind(ts.SyntaxKind.SetAccessor)?.getName();
+        case SyntaxKind.SetAccessor:
+            return a.asKind(SyntaxKind.SetAccessor)!.getName();
     
-        case ts.SyntaxKind.FunctionDeclaration:
-            if (a.asKind(ts.SyntaxKind.FunctionDeclaration).getTypeParameters().length>0){
-                return a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getName()+getParameters(a);
+        case SyntaxKind.FunctionDeclaration:
+            const fKind = a.asKind(SyntaxKind.FunctionDeclaration);
+            if (fKind && fKind.getTypeParameters().length > 0) {
+                return fKind.getName() + getParameters(a);
             } else {
-                return a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getName();
+                return fKind?.getName() || "";
             }
 
-        case ts.SyntaxKind.FunctionExpression:
-            return (a.asKind(ts.SyntaxKind.FunctionExpression)?.getName()) ? a.asKind(ts.SyntaxKind.FunctionExpression)?.getName() : "anonymous";
+        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:
@@ -245,14 +188,22 @@ export function getNameOfNode(a: Node): string {
  * @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 ts.SyntaxKind.ClassDeclaration:    
-            return "<" + a.asKind(ts.SyntaxKind.ClassDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
-        case ts.SyntaxKind.InterfaceDeclaration:
-            return "<" + a.asKind(ts.SyntaxKind.InterfaceDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
-        case ts.SyntaxKind.MethodDeclaration:
-            return "<" + a.asKind(ts.SyntaxKind.MethodDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
-        case ts.SyntaxKind.FunctionDeclaration:
-            return "<" + a.asKind(ts.SyntaxKind.FunctionDeclaration)?.getTypeParameters().map(tp => tp.getName()).join(", ") + ">";
+        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/src/lib/famix/famix_JSON_exporter.ts

@@ -0,0 +1,56 @@
+import { FamixBaseElement } from "./famix_base_element";
+
+/**
+ * This class is used to export Famix elements to JSON
+ */
+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: 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
+     */
+    public addProperty(name: string, prop: unknown): void {
+        if (prop instanceof Set) {
+            const valueArray: Array<unknown> = [];
+            for (const value of Array.from(prop.values())) {
+                if (value instanceof FamixBaseElement) {
+                    valueArray.push({ "ref": value.id });
+                }
+                else {
+                    valueArray.push(value);
+                }
+            }
+            this.bufferArray[name] = valueArray;
+        }
+        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
+     */
+    public getJSON(): string {
+        return JSON.stringify(this.bufferArray);
+    }
+}

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})`);
+    }
+}

package/src/lib/famix/famix_repository.ts

@@ -0,0 +1,243 @@
+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
+ */
+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.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;
+    }
+
+    /**
+     * 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
+     */
+    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
+     */
+    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: { format: string; }) {
+        if (arg0.format === "json") {
+            return this.getJSON();
+        } else {
+            throw new Error("Unsupported format");
+        }
+    }
+
+
+    // Only for tests
+
+    /**
+     * Gets all Famix entities
+     * @returns All Famix entities
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    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
+     */
+    public addElement(element: FamixBaseElement): void {
+        if (element instanceof Class) {
+            this.famixClasses.add(element);
+        } else if (element instanceof Interface) {
+            this.famixInterfaces.add(element);
+        } else if (element instanceof Module) {
+            this.famixModules.add(element);
+        } else if (element instanceof Variable) {
+            this.famixVariables.add(element);
+        } else if (element instanceof Method) {
+            this.famixMethods.add(element);
+        } else if (element instanceof FamixFunctionEntity || element instanceof ArrowFunction) {
+            this.famixFunctions.add(element);
+        } 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
+     */
+    public getJSON(): string {
+        let ret = "[";
+        for (const element of Array.from(this.elements.values())) {
+            ret = ret + element.getJSON() + ",";
+        }
+        ret = ret.substring(0, ret.length - 1);
+        return ret + "]";
+    }
+}