ts2famix 1.0.11 → 1.0.13

package/dist/analyze_functions/processFiles.js

@@ -1,540 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessFiles = void 0;
-const ts_morph_1 = require("ts-morph");
-const Famix = __importStar(require("../lib/famix/src/model/famix"));
-const cyclomatic_service_1 = require("../lib/ts-complex/cyclomatic-service");
-/**
- * This class is used to build a Famix model for an array of source files
- */
-class ProcessFiles {
-    /**
-     * Initializes the ProcessFiles object
-     * @param famixFunctions FamixFunctions object, it contains all the functions needed to create Famix entities
-     */
-    constructor(famixFunctions) {
-        this.methodsAndFunctionsWithId = new Map(); // Maps the Famix method, constructor, getter, setter and function ids to their ts-morph method, constructor, getter, setter or function object
-        this.accesses = new Map(); // Maps the Famix parameter, variable, property and enum value ids to their ts-morph parameter, variable, property or enum member object
-        this.classes = new Array(); // Array of all the classes of the source files
-        this.interfaces = new Array(); // Array of all the interfaces of the source files
-        this.modules = new Array(); // Array of all the source files which are modules
-        this.exports = new Array(); // Array of all the exports
-        this.famixFunctions = famixFunctions;
-    }
-    /**
-     * Builds a Famix model for an array of source files
-     * @param sourceFiles An array of source files
-     */
-    processFiles(sourceFiles) {
-        sourceFiles.forEach(file => {
-            console.info(`processFiles: File: >>>>>>>>>> ${file.getBaseName()}`);
-            // Computes the cyclomatic complexity metrics for the current source file
-            this.currentCC = (0, cyclomatic_service_1.calculate)(file.getFilePath());
-            this.processFile(file);
-        });
-    }
-    /**
-     * Gets the map of methods and functions with their id
-     * @returns The map of methods and functions with their id
-     */
-    getMethodsAndFunctionsWithId() {
-        return this.methodsAndFunctionsWithId;
-    }
-    /**
-     * Gets the map of accesses
-     * @returns The map of accesses
-     */
-    getAccesses() {
-        return this.accesses;
-    }
-    /**
-     * Gets the array of classes
-     * @returns The array of classes
-     */
-    getClasses() {
-        return this.classes;
-    }
-    /**
-     * Gets the array of interfaces
-     * @returns The array of interfaces
-     */
-    getInterfaces() {
-        return this.interfaces;
-    }
-    /**
-     * Gets the array of modules
-     * @returns The array of modules
-     */
-    getModules() {
-        return this.modules;
-    }
-    /**
-     * Gets the array of exports
-     * @returns The array of exports
-     */
-    getExports() {
-        return this.exports;
-    }
-    /**
-     * Builds a Famix model for a source file
-     * @param f A source file
-     */
-    processFile(f) {
-        const isModule = this.isModule(f);
-        if (isModule) {
-            this.modules.push(f);
-        }
-        const fmxFile = this.famixFunctions.createOrGetFamixFile(f, isModule);
-        console.info(`processFile: file: ${f.getBaseName()}, fqn = ${fmxFile.getFullyQualifiedName()}`);
-        this.processComments(f, fmxFile);
-        this.processAliases(f, fmxFile);
-        this.processClasses(f, fmxFile);
-        this.processInterfaces(f, fmxFile);
-        this.processVariables(f, fmxFile);
-        this.processEnums(f, fmxFile);
-        this.processFunctions(f, fmxFile);
-        this.processNamespaces(f, fmxFile);
-    }
-    /**
-     * Builds a Famix model for a namespace
-     * @param m A namespace
-     * @returns A Famix.Namespace representing the namespace
-     */
-    processNamespace(m) {
-        const fmxNamespace = this.famixFunctions.createOrGetFamixNamespace(m);
-        console.info(`processNamespace: namespace: ${m.getName()}, (${m.getType().getText()}), ${fmxNamespace.getFullyQualifiedName()}`);
-        this.processComments(m, fmxNamespace);
-        this.processAliases(m, fmxNamespace);
-        this.processClasses(m, fmxNamespace);
-        this.processInterfaces(m, fmxNamespace);
-        this.processVariables(m, fmxNamespace);
-        this.processEnums(m, fmxNamespace);
-        this.processFunctions(m, fmxNamespace);
-        this.processNamespaces(m, fmxNamespace);
-        return fmxNamespace;
-    }
-    /**
-     * Builds a Famix model for the aliases of a container
-     * @param m A container (a source file, a namespace, a function or a method)
-     * @param fmxScope The Famix model of the container
-     */
-    processAliases(m, fmxScope) {
-        console.info(`processAliases: ---------- Finding Aliases:`);
-        m.getTypeAliases().forEach(a => {
-            const fmxAlias = this.processAlias(a);
-            fmxScope.addAlias(fmxAlias);
-        });
-    }
-    /**
-     * Builds a Famix model for the classes of a container
-     * @param m A container (a source file or a namespace)
-     * @param fmxScope The Famix model of the container
-     */
-    processClasses(m, fmxScope) {
-        console.info(`processClasses: ---------- Finding Classes:`);
-        m.getClasses().forEach(c => {
-            const fmxClass = this.processClass(c);
-            fmxScope.addType(fmxClass);
-        });
-    }
-    /**
-     * Builds a Famix model for the interfaces of a container
-     * @param m A container (a source file or a namespace)
-     * @param fmxScope The Famix model of the container
-     */
-    processInterfaces(m, fmxScope) {
-        console.info(`processInterfaces: ---------- Finding Interfaces:`);
-        m.getInterfaces().forEach(i => {
-            const fmxInterface = this.processInterface(i);
-            fmxScope.addType(fmxInterface);
-        });
-    }
-    /**
-     * Builds a Famix model for the variables of a container
-     * @param m A container (a source file, a namespace, a function or a method)
-     * @param fmxScope The Famix model of the container
-     */
-    processVariables(m, fmxScope) {
-        console.info(`processVariables: ---------- Finding Variables:`);
-        m.getVariableStatements().forEach(v => {
-            const fmxVariables = this.processVariableStatement(v);
-            fmxVariables.forEach(fmxVariable => {
-                fmxScope.addVariable(fmxVariable);
-            });
-        });
-    }
-    /**
-     * Builds a Famix model for the enums of a container
-     * @param m A container (a source file, a namespace, a function or a method)
-     * @param fmxScope The Famix model of the container
-     */
-    processEnums(m, fmxScope) {
-        console.info(`processEnums: ---------- Finding Enums:`);
-        m.getEnums().forEach(e => {
-            const fmxEnum = this.processEnum(e);
-            fmxScope.addType(fmxEnum);
-        });
-    }
-    /**
-     * Builds a Famix model for the functions of a container
-     * @param m A container (a source file, a namespace, a function or a method)
-     * @param fmxScope The Famix model of the container
-     */
-    processFunctions(m, fmxScope) {
-        console.info(`processFunctions: ---------- Finding Functions:`);
-        m.getFunctions().forEach(f => {
-            const fmxFunction = this.processFunction(f);
-            fmxScope.addFunction(fmxFunction);
-        });
-    }
-    /**
-     * Builds a Famix model for the namespaces of a container
-     * @param m A container (a source file or a namespace)
-     * @param fmxScope The Famix model of the container
-     */
-    processNamespaces(m, fmxScope) {
-        console.info(`processNamespaces: ---------- Finding Namespaces:`);
-        m.getModules().forEach(md => {
-            const fmxNsp = this.processNamespace(md);
-            fmxScope.addNamespace(fmxNsp);
-        });
-    }
-    /**
-     * Builds a Famix model for an alias
-     * @param a An alias
-     * @returns A Famix.Alias representing the alias
-     */
-    processAlias(a) {
-        const fmxAlias = this.famixFunctions.createFamixAlias(a);
-        console.info(`processAlias: alias: ${a.getName()}, (${a.getType().getText()}), fqn = ${fmxAlias.getFullyQualifiedName()}`);
-        this.processComments(a, fmxAlias);
-        return fmxAlias;
-    }
-    /**
-     * Builds a Famix model for a class
-     * @param c A class
-     * @returns A Famix.Class or a Famix.ParameterizableClass representing the class
-     */
-    processClass(c) {
-        this.classes.push(c);
-        const fmxClass = this.famixFunctions.createOrGetFamixClass(c);
-        console.info(`processClass: class: ${c.getName()}, (${c.getType().getText()}), fqn = ${fmxClass.getFullyQualifiedName()}`);
-        this.processComments(c, fmxClass);
-        this.processDecorators(c, fmxClass);
-        this.processStructuredType(c, fmxClass);
-        c.getConstructors().forEach(con => {
-            const fmxCon = this.processMethod(con);
-            fmxClass.addMethod(fmxCon);
-        });
-        c.getGetAccessors().forEach(acc => {
-            const fmxAcc = this.processMethod(acc);
-            fmxClass.addMethod(fmxAcc);
-        });
-        c.getSetAccessors().forEach(acc => {
-            const fmxAcc = this.processMethod(acc);
-            fmxClass.addMethod(fmxAcc);
-        });
-        return fmxClass;
-    }
-    /**
-     * Builds a Famix model for an interface
-     * @param i An interface
-     * @returns A Famix.Interface or a Famix.ParameterizableInterface representing the interface
-     */
-    processInterface(i) {
-        this.interfaces.push(i);
-        const fmxInterface = this.famixFunctions.createOrGetFamixInterface(i);
-        console.info(`processInterface: interface: ${i.getName()}, (${i.getType().getText()}), fqn = ${fmxInterface.getFullyQualifiedName()}`);
-        this.processComments(i, fmxInterface);
-        this.processStructuredType(i, fmxInterface);
-        return fmxInterface;
-    }
-    /**
-     * Builds a Famix model for the type parameters, properties and methods of a structured type
-     * @param c A structured type (a class or an interface)
-     * @param fmxScope The Famix model of the structured type
-     */
-    processStructuredType(c, fmxScope) {
-        console.info(`processStructuredType: ---------- Finding Properties and Methods:`);
-        if (fmxScope instanceof Famix.ParameterizableClass || fmxScope instanceof Famix.ParameterizableInterface) {
-            this.processTypeParameters(c, fmxScope);
-        }
-        c.getProperties().forEach(prop => {
-            const fmxProperty = this.processProperty(prop);
-            fmxScope.addProperty(fmxProperty);
-        });
-        c.getMethods().forEach(m => {
-            const fmxMethod = this.processMethod(m);
-            fmxScope.addMethod(fmxMethod);
-        });
-    }
-    /**
-     * Builds a Famix model for a property
-     * @param p A property
-     * @returns A Famix.Property representing the property
-     */
-    processProperty(p) {
-        const fmxProperty = this.famixFunctions.createFamixProperty(p);
-        console.info(`processProperty: property: ${p.getName()}, (${p.getType().getText()}), fqn = ${fmxProperty.getFullyQualifiedName()}`);
-        this.processComments(p, fmxProperty);
-        if (!(p instanceof ts_morph_1.PropertySignature)) {
-            this.processDecorators(p, fmxProperty);
-            this.accesses.set(fmxProperty.id, p);
-        }
-        return fmxProperty;
-    }
-    /**
-     * Builds a Famix model for a method or an accessor
-     * @param m A method or an accessor
-     * @returns A Famix.Method or a Famix.Accessor representing the method or the accessor
-     */
-    processMethod(m) {
-        const fmxMethod = this.famixFunctions.createFamixMethod(m, this.currentCC);
-        console.info(`processMethod: method: ${!(m instanceof ts_morph_1.ConstructorDeclaration) ? m.getName() : "constructor"}, (${m.getType().getText()}), parent: ${m.getParent().getName()}, fqn = ${fmxMethod.getFullyQualifiedName()}`);
-        this.processComments(m, fmxMethod);
-        this.processTypeParameters(m, fmxMethod);
-        this.processParameters(m, fmxMethod);
-        if (!(m instanceof ts_morph_1.MethodSignature)) {
-            this.processAliases(m, fmxMethod);
-            this.processVariables(m, fmxMethod);
-            this.processEnums(m, fmxMethod);
-            this.processFunctions(m, fmxMethod);
-            this.processFunctionExpressions(m, fmxMethod);
-            this.methodsAndFunctionsWithId.set(fmxMethod.id, m);
-        }
-        if (m instanceof ts_morph_1.MethodDeclaration || m instanceof ts_morph_1.GetAccessorDeclaration || m instanceof ts_morph_1.SetAccessorDeclaration) {
-            this.processDecorators(m, fmxMethod);
-        }
-        return fmxMethod;
-    }
-    /**
-     * Builds a Famix model for a function
-     * @param f A function
-     * @returns A Famix.Function representing the function
-     */
-    processFunction(f) {
-        const fmxFunction = this.famixFunctions.createFamixFunction(f, this.currentCC);
-        console.info(`processFunction: function: ${(f.getName()) ? f.getName() : "anonymous"}, (${f.getType().getText()}), fqn = ${fmxFunction.getFullyQualifiedName()}`);
-        this.processComments(f, fmxFunction);
-        this.processAliases(f, fmxFunction);
-        this.processTypeParameters(f, fmxFunction);
-        this.processParameters(f, fmxFunction);
-        this.processVariables(f, fmxFunction);
-        this.processEnums(f, fmxFunction);
-        this.processFunctions(f, fmxFunction);
-        if (f instanceof ts_morph_1.FunctionDeclaration && !(f.getParent() instanceof ts_morph_1.Block)) {
-            this.processFunctionExpressions(f, fmxFunction);
-        }
-        this.methodsAndFunctionsWithId.set(fmxFunction.id, f);
-        return fmxFunction;
-    }
-    /**
-     * Builds a Famix model for the function expressions of a function or a method
-     * @param f A function or a method
-     * @param fmxScope The Famix model of the function or the method
-     */
-    processFunctionExpressions(f, fmxScope) {
-        console.info(`processFunctionExpressions: ---------- Finding Function Expressions:`);
-        const functionExpressions = f.getDescendantsOfKind(ts_morph_1.SyntaxKind.FunctionExpression);
-        functionExpressions.forEach((func) => {
-            const fmxFunc = this.processFunction(func);
-            fmxScope.addFunction(fmxFunc);
-        });
-    }
-    /**
-     * Builds a Famix model for the parameters of a method or a function
-     * @param m A method or a function
-     * @param fmxScope The Famix model of the method or the function
-     */
-    processParameters(m, fmxScope) {
-        console.info(`processParameters: ---------- Finding Parameters:`);
-        m.getParameters().forEach(param => {
-            const fmxParam = this.processParameter(param);
-            fmxScope.addParameter(fmxParam);
-        });
-    }
-    /**
-     * Builds a Famix model for a parameter
-     * @param p A parameter
-     * @returns A Famix.Parameter representing the parameter
-     */
-    processParameter(p) {
-        const fmxParam = this.famixFunctions.createFamixParameter(p);
-        console.info(`processParameter: parameter: ${p.getName()}, (${p.getType().getText()}), fqn = ${fmxParam.getFullyQualifiedName()}`);
-        this.processComments(p, fmxParam);
-        this.processDecorators(p, fmxParam);
-        const parent = p.getParent();
-        if (!(parent instanceof ts_morph_1.MethodSignature)) {
-            this.accesses.set(fmxParam.id, p);
-        }
-        return fmxParam;
-    }
-    /**
-     * Builds a Famix model for the type parameters of a class, an interface, a method or a function
-     * @param e A class, an interface, a method or a function
-     * @param fmxScope The Famix model of the class, the interface, the method or the function
-     */
-    processTypeParameters(e, fmxScope) {
-        console.info(`processTypeParameters: ---------- Finding Type Parameters:`);
-        e.getTypeParameters().forEach(tp => {
-            const fmxParam = this.processTypeParameter(tp);
-            fmxScope.addTypeParameter(fmxParam);
-        });
-    }
-    /**
-     * Builds a Famix model for a type parameter
-     * @param tp A type parameter
-     * @returns A Famix.TypeParameter representing the type parameter
-     */
-    processTypeParameter(tp) {
-        const fmxTypeParameter = this.famixFunctions.createFamixTypeParameter(tp);
-        console.info(`processTypeParameter: type parameter: ${tp.getName()}, (${tp.getType().getText()}), fqn = ${fmxTypeParameter.getFullyQualifiedName()}`);
-        this.processComments(tp, fmxTypeParameter);
-        return fmxTypeParameter;
-    }
-    /**
-     * Builds a Famix model for the variables of a variable statement
-     * @param v A variable statement
-     * @returns An array of Famix.Variable representing the variables
-     */
-    processVariableStatement(v) {
-        const fmxVariables = new Array();
-        console.info(`processVariableStatement: variable statement: variable statement, (${v.getType().getText()}), ${v.getDeclarationKindKeyword().getText()}`);
-        v.getDeclarations().forEach(variable => {
-            const fmxVar = this.processVariable(variable);
-            this.processComments(v, fmxVar);
-            fmxVariables.push(fmxVar);
-        });
-        return fmxVariables;
-    }
-    /**
-     * Builds a Famix model for a variable
-     * @param v A variable
-     * @returns A Famix.Variable representing the variable
-     */
-    processVariable(v) {
-        const fmxVar = this.famixFunctions.createFamixVariable(v);
-        console.info(`processVariable: variable: ${v.getName()}, (${v.getType().getText()}), ${v.getInitializer() ? "initializer: " + v.getInitializer().getText() : "initializer: "}, fqn = ${fmxVar.getFullyQualifiedName()}`);
-        this.processComments(v, fmxVar);
-        this.accesses.set(fmxVar.id, v);
-        return fmxVar;
-    }
-    /**
-     * Builds a Famix model for an enum
-     * @param e An enum
-     * @returns A Famix.Enum representing the enum
-     */
-    processEnum(e) {
-        const fmxEnum = this.famixFunctions.createFamixEnum(e);
-        console.info(`processEnum: enum: ${e.getName()}, (${e.getType().getText()}), fqn = ${fmxEnum.getFullyQualifiedName()}`);
-        this.processComments(e, fmxEnum);
-        e.getMembers().forEach(m => {
-            const fmxEnumValue = this.processEnumValue(m);
-            fmxEnum.addValue(fmxEnumValue);
-        });
-        return fmxEnum;
-    }
-    /**
-     * Builds a Famix model for an enum member
-     * @param v An enum member
-     * @returns A Famix.EnumValue representing the enum member
-     */
-    processEnumValue(v) {
-        const fmxEnumValue = this.famixFunctions.createFamixEnumValue(v);
-        console.info(`processEnumValue: enum value: ${v.getName()}, (${v.getType().getText()}), fqn = ${fmxEnumValue.getFullyQualifiedName()}`);
-        this.processComments(v, fmxEnumValue);
-        this.accesses.set(fmxEnumValue.id, v);
-        return fmxEnumValue;
-    }
-    /**
-     * Builds a Famix model for the decorators of a class, a method, a parameter or a property
-     * @param e A class, a method, a parameter or a property
-     * @param fmxScope The Famix model of the class, the method, the parameter or the property
-     */
-    processDecorators(e, fmxScope) {
-        console.info(`processDecorators: ---------- Finding Decorators:`);
-        e.getDecorators().forEach(dec => {
-            const fmxDec = this.processDecorator(dec, e);
-            fmxScope.addDecorator(fmxDec);
-        });
-    }
-    /**
-     * Builds a Famix model for a decorator
-     * @param d A decorator
-     * @param e A class, a method, a parameter or a property
-     * @returns A Famix.Decorator representing the decorator
-     */
-    processDecorator(d, e) {
-        const fmxDec = this.famixFunctions.createOrGetFamixDecorator(d, e);
-        console.info(`processDecorator: decorator: ${d.getName()}, (${d.getType().getText()}), fqn = ${fmxDec.getFullyQualifiedName()}`);
-        this.processComments(d, fmxDec);
-        return fmxDec;
-    }
-    /**
-     * Builds a Famix model for the comments
-     * @param e A ts-morph element
-     * @param fmxScope The Famix model of the named entity
-     */
-    processComments(e, fmxScope) {
-        console.info(`processComments: ---------- Finding Comments:`);
-        e.getLeadingCommentRanges().forEach(c => {
-            const fmxComment = this.processComment(c, fmxScope);
-            fmxScope.addComment(fmxComment);
-        });
-        e.getTrailingCommentRanges().forEach(c => {
-            const fmxComment = this.processComment(c, fmxScope);
-            fmxScope.addComment(fmxComment);
-        });
-    }
-    /**
-     * Builds a Famix model for a comment
-     * @param c A comment
-     * @param fmxScope The Famix model of the comment's container
-     * @returns A Famix.Comment representing the comment
-     */
-    processComment(c, fmxScope) {
-        let isJSDoc = false;
-        if (c.getText().substring(0, 3) === "/**") {
-            isJSDoc = true;
-        }
-        const fmxComment = this.famixFunctions.createFamixComment(c, fmxScope, isJSDoc);
-        console.info(`processComment: comment: ${c.getText()}`);
-        return fmxComment;
-    }
-    /**
-     * Checks if the file has any imports or exports to be considered a module
-     * @param sourceFile A source file
-     * @returns A boolean indicating if the file is a module
-     */
-    isModule(sourceFile) {
-        if (sourceFile.getImportDeclarations().length > 0 || sourceFile.getExportedDeclarations().size > 0) {
-            this.exports.push(sourceFile.getExportedDeclarations());
-            return true;
-        }
-        return false;
-    }
-}
-exports.ProcessFiles = ProcessFiles;

package/dist/analyze_functions/processImportClauses.js

@@ -1,70 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessImportClauses = void 0;
-/**
- * This class is used to build a Famix model for the import clauses
- */
-class ProcessImportClauses {
-    /**
-     * Initializes the ProcessImportClauses 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 import clauses of the source files which are modules
-     * @param modules An array of modules
-     * @param exports An array of maps of exported declarations
-     */
-    processImportClauses(modules, exports) {
-        console.info(`processImportClauses: Creating import clauses:`);
-        modules.forEach(f => {
-            f.getImportDeclarations().forEach(i => {
-                const path = this.getModulePath(i);
-                i.getNamedImports().forEach(ni => {
-                    console.info(`processImportClauses: Importing (named) ${ni.getName()} from ${i.getModuleSpecifierValue()}`);
-                    const importedEntityName = ni.getName();
-                    let bool = false;
-                    exports.forEach(e => {
-                        if (e.has(importedEntityName)) {
-                            bool = true;
-                        }
-                    });
-                    this.famixFunctions.createFamixImportClause(f, i.getModuleSpecifierValue(), path, ni, bool, false);
-                });
-                const defaultImport = i.getDefaultImport();
-                if (defaultImport !== undefined) {
-                    console.info(`processImportClauses: Importing (default) ${defaultImport.getText()} from ${i.getModuleSpecifierValue()}`);
-                    this.famixFunctions.createFamixImportClause(f, i.getModuleSpecifierValue(), path, defaultImport, false, true);
-                }
-                const namespaceImport = i.getNamespaceImport();
-                if (namespaceImport !== undefined) {
-                    console.info(`processImportClauses: Importing (namespace) ${namespaceImport.getText()} from ${i.getModuleSpecifierValue()}`);
-                    this.famixFunctions.createFamixImportClause(f, i.getModuleSpecifierValue(), path, namespaceImport, false, false);
-                }
-            });
-        });
-    }
-    /**
-     * Gets the path of a module to be imported
-     * @param i An import declaration
-     * @returns The path of the module to be imported
-     */
-    getModulePath(i) {
-        let path;
-        if (i.getModuleSpecifierSourceFile() === undefined) {
-            if (i.getModuleSpecifierValue().substring(i.getModuleSpecifierValue().length - 3) === ".ts") {
-                path = i.getModuleSpecifierValue();
-            }
-            else {
-                path = i.getModuleSpecifierValue() + ".ts";
-            }
-        }
-        else {
-            path = i.getModuleSpecifierSourceFile().getFilePath();
-        }
-        return path;
-    }
-}
-exports.ProcessImportClauses = ProcessImportClauses;

package/dist/analyze_functions/processInheritances.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ProcessInheritances = void 0;
-const ts_morph_1 = require("ts-morph");
-/**
- * This class is used to build a Famix model for the inheritances
- */
-class ProcessInheritances {
-    /**
-     * Initializes the ProcessInheritances 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 inheritances of the classes and interfaces of the source files
-     * @param classes An array of classes
-     * @param interfaces An array of interfaces
-     */
-    processInheritances(classes, interfaces) {
-        console.info(`processInheritances: Creating inheritances:`);
-        classes.forEach(cls => {
-            console.info(`processInheritances: Checking class inheritance for ${cls.getName()}`);
-            const extClass = cls.getBaseClass();
-            if (extClass !== undefined) {
-                this.famixFunctions.createFamixInheritance(cls, extClass);
-                console.info(`processInheritances: class: ${cls.getName()}, (${cls.getType().getText()}), extClass: ${extClass.getName()}, (${extClass.getType().getText()})`);
-            }
-            console.info(`processInheritances: Checking interface inheritance for ${cls.getName()}`);
-            const implementedInterfaces = this.getImplementedOrExtendedInterfaces(interfaces, cls);
-            implementedInterfaces.forEach(impInter => {
-                this.famixFunctions.createFamixInheritance(cls, impInter);
-                console.info(`processInheritances: class: ${cls.getName()}, (${cls.getType().getText()}), impInter: ${(impInter instanceof ts_morph_1.InterfaceDeclaration) ? impInter.getName() : impInter.getExpression().getText()}, (${(impInter instanceof ts_morph_1.InterfaceDeclaration) ? impInter.getType().getText() : impInter.getExpression().getText()})`);
-            });
-        });
-        interfaces.forEach(inter => {
-            console.info(`processInheritances: Checking interface inheritance for ${inter.getName()}`);
-            const extendedInterfaces = this.getImplementedOrExtendedInterfaces(interfaces, inter);
-            extendedInterfaces.forEach(extInter => {
-                this.famixFunctions.createFamixInheritance(inter, extInter);
-                console.info(`processInheritances: inter: ${inter.getName()}, (${inter.getType().getText()}), extInter: ${(extInter instanceof ts_morph_1.InterfaceDeclaration) ? extInter.getName() : extInter.getExpression().getText()}, (${(extInter instanceof ts_morph_1.InterfaceDeclaration) ? extInter.getType().getText() : extInter.getExpression().getText()})`);
-            });
-        });
-    }
-    /**
-     * Gets the interfaces implemented or extended by a class or an interface
-     * @param interfaces An array of interfaces
-     * @param subClass A class or an interface
-     * @returns An array of InterfaceDeclaration and ExpressionWithTypeArguments containing the interfaces implemented or extended by the subClass
-     */
-    getImplementedOrExtendedInterfaces(interfaces, subClass) {
-        let impOrExtInterfaces;
-        if (subClass instanceof ts_morph_1.ClassDeclaration) {
-            impOrExtInterfaces = subClass.getImplements();
-        }
-        else {
-            impOrExtInterfaces = subClass.getExtends();
-        }
-        const interfacesNames = interfaces.map(i => i.getName());
-        const implementedOrExtendedInterfaces = new Array();
-        impOrExtInterfaces.forEach(i => {
-            if (interfacesNames.includes(i.getExpression().getText())) {
-                implementedOrExtendedInterfaces.push(interfaces[interfacesNames.indexOf(i.getExpression().getText())]);
-            }
-            else {
-                implementedOrExtendedInterfaces.push(i);
-            }
-        });
-        return implementedOrExtendedInterfaces;
-    }
-}
-exports.ProcessInheritances = ProcessInheritances;