ts2famix 1.3.1 → 1.4.0

package/src/analyze_functions/processImportClauses.ts

@@ -1,95 +0,0 @@
-import { ImportDeclaration, SourceFile, ExportedDeclarations } from "ts-morph";
-import { FamixFunctions } from "../famix_functions/famix_functions";
-import { logger } from "../analyze";
-
-/**
- * This class is used to build a Famix model for the import clauses
- */
-export class ProcessImportClauses {
-
-    private famixFunctions: FamixFunctions; // FamixFunctions object, it contains all the functions needed to create Famix entities
-
-    /**
-     * Initializes the ProcessImportClauses object
-     * @param famixFunctions FamixFunctions object, it contains all the functions needed to create Famix entities
-     */
-    constructor(famixFunctions: 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
-     */
-    public processImportClauses(modules: Array<SourceFile>, exports: Array<ReadonlyMap<string, ExportedDeclarations[]>>): void {
-        logger.info(`processImportClauses: Creating import clauses:`);
-        modules.forEach(module => {
-            module.getImportDeclarations().forEach(impDecl => {
-                const path = this.getModulePath(impDecl);
-
-                impDecl.getNamedImports().forEach(namedImport => {
-                    logger.debug(`processImportClauses: Importing (named) ${namedImport.getName()} from ${impDecl.getModuleSpecifierValue()}`);
-                    const importedEntityName = namedImport.getName();
-                    let importFoundInExports = false;
-                    exports.forEach(e => {
-                        if (e.has(importedEntityName)) {
-                            importFoundInExports = true;
-                        }
-                    });
-                    this.famixFunctions.createFamixImportClause({importDeclaration: impDecl,
-                        importer: module, 
-                        moduleSpecifierFilePath: path, 
-                        importElement: namedImport, 
-                        isInExports: importFoundInExports, 
-                        isDefaultExport: false});
-                });
-
-                const defaultImport = impDecl.getDefaultImport();
-                if (defaultImport !== undefined) {
-                    logger.debug(`processImportClauses: Importing (default) ${defaultImport.getText()} from ${impDecl.getModuleSpecifierValue()}`);
-                    // call with module, impDecl.getModuleSpecifierValue(), path, defaultImport, false, true
-                    this.famixFunctions.createFamixImportClause({importDeclaration: impDecl,
-                        importer: module,
-                        moduleSpecifierFilePath: path,
-                        importElement: defaultImport,
-                        isInExports: false,
-                        isDefaultExport: true});
-                }
-
-                const namespaceImport = impDecl.getNamespaceImport();
-                if (namespaceImport !== undefined) {
-                    logger.debug(`processImportClauses: Importing (namespace) ${namespaceImport.getText()} from ${impDecl.getModuleSpecifierValue()}`);
-                    this.famixFunctions.createFamixImportClause({importDeclaration: impDecl,
-                        importer: module, 
-                        moduleSpecifierFilePath: path, 
-                        importElement: namespaceImport, 
-                        isInExports: false, 
-                        isDefaultExport: false});
-                    // this.famixFunctions.createFamixImportClause(module, impDecl.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
-     */
-    private getModulePath(i: ImportDeclaration): string {
-        let path: string;
-        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;
-    }
-}

package/src/analyze_functions/processInheritances.ts

@@ -1,85 +0,0 @@
-import { ClassDeclaration, InterfaceDeclaration, ExpressionWithTypeArguments } from "ts-morph";
-import { FamixFunctions } from "../famix_functions/famix_functions";
-import { logger } from "../analyze";
-
-/**
- * This class is used to build a Famix model for the inheritances
- */
-export class ProcessInheritances {
-
-    private famixFunctions: FamixFunctions; // FamixFunctions object, it contains all the functions needed to create Famix entities
-
-    /**
-     * Initializes the ProcessInheritances object
-     * @param famixFunctions FamixFunctions object, it contains all the functions needed to create Famix entities
-     */
-    constructor(famixFunctions: 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
-     */
-    public processInheritances(classes: ClassDeclaration[], interfaces: InterfaceDeclaration[]): void {
-        logger.info(`processInheritances: Creating inheritances:`);
-        classes.forEach(cls => {
-            logger.debug(`processInheritances: Checking class inheritance for ${cls.getName()}`);
-            const extClass = cls.getBaseClass();
-            if (extClass !== undefined) {
-                this.famixFunctions.createFamixInheritance(cls, extClass);
-                
-                logger.debug(`processInheritances: class: ${cls.getName()}, (${cls.getType().getText()}), extClass: ${extClass.getName()}, (${extClass.getType().getText()})`);
-            }
-
-            logger.debug(`processInheritances: Checking interface inheritance for ${cls.getName()}`);
-            const implementedInterfaces = this.getImplementedOrExtendedInterfaces(interfaces, cls);
-            implementedInterfaces.forEach(impInter => {
-                this.famixFunctions.createFamixInheritance(cls, impInter);
-
-                logger.debug(`processInheritances: class: ${cls.getName()}, (${cls.getType().getText()}), impInter: ${(impInter instanceof InterfaceDeclaration) ? impInter.getName() : impInter.getExpression().getText()}, (${(impInter instanceof InterfaceDeclaration) ? impInter.getType().getText() : impInter.getExpression().getText()})`);
-            });
-        });
-
-        interfaces.forEach(inter => {
-            logger.debug(`processInheritances: Checking interface inheritance for ${inter.getName()}`);
-            const extendedInterfaces = this.getImplementedOrExtendedInterfaces(interfaces, inter);
-            extendedInterfaces.forEach(extInter => {
-                this.famixFunctions.createFamixInheritance(inter, extInter);
-
-                logger.debug(`processInheritances: inter: ${inter.getName()}, (${inter.getType().getText()}), extInter: ${(extInter instanceof InterfaceDeclaration) ? extInter.getName() : extInter.getExpression().getText()}, (${(extInter instanceof 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
-     */
-    private getImplementedOrExtendedInterfaces(interfaces: Array<InterfaceDeclaration>, subClass: ClassDeclaration | InterfaceDeclaration): Array<InterfaceDeclaration | ExpressionWithTypeArguments> {
-        let impOrExtInterfaces: Array<ExpressionWithTypeArguments>;
-        if (subClass instanceof ClassDeclaration) {
-            impOrExtInterfaces = subClass.getImplements();
-        }
-        else {
-            impOrExtInterfaces = subClass.getExtends();
-        }
-
-        const interfacesNames = interfaces.map(i => i.getName());
-        const implementedOrExtendedInterfaces = new Array<InterfaceDeclaration | ExpressionWithTypeArguments>();
-
-        impOrExtInterfaces.forEach(i => {
-            if (interfacesNames.includes(i.getExpression().getText())) {
-                implementedOrExtendedInterfaces.push(interfaces[interfacesNames.indexOf(i.getExpression().getText())]);
-            }
-            else {
-                implementedOrExtendedInterfaces.push(i);
-            }
-        });
-
-        return implementedOrExtendedInterfaces;
-    }
-}

package/src/analyze_functions/processInvocations.ts

@@ -1,52 +0,0 @@
-import { MethodDeclaration, FunctionDeclaration, Identifier, ConstructorDeclaration, GetAccessorDeclaration, SetAccessorDeclaration, FunctionExpression } from "ts-morph";
-import { FamixFunctions } from "../famix_functions/famix_functions";
-import { logger } from "../analyze";
-
-/**
- * This class is used to build a Famix model for the invocations
- */
-export class ProcessInvocations {
-
-    private famixFunctions: FamixFunctions; // FamixFunctions object, it contains all the functions needed to create Famix entities
-
-    /**
-     * Initializes the ProcessInvocations object
-     * @param famixFunctions FamixFunctions object, it contains all the functions needed to create Famix entities
-     */
-    constructor(famixFunctions: FamixFunctions) {
-        this.famixFunctions = famixFunctions;
-    }
-
-    /**
-     * Builds a Famix model for the invocations of the methods and functions of the source files
-     * @param methodsAndFunctionsWithId A map of methods and functions with their id
-     */
-    public processInvocations(methodsAndFunctionsWithId: Map<number, MethodDeclaration | ConstructorDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression>): void {
-        logger.info(`Creating invocations:`);
-        methodsAndFunctionsWithId.forEach((m, id) => {
-            logger.debug(`Invocations to ${(m instanceof MethodDeclaration || m instanceof GetAccessorDeclaration || m instanceof SetAccessorDeclaration || m instanceof FunctionDeclaration) ? m.getName() : ((m instanceof ConstructorDeclaration) ? 'constructor' : (m.getName() ? m.getName() : 'anonymous'))}`);
-            try {
-                const temp_nodes = m.findReferencesAsNodes() as Array<Identifier>;
-                temp_nodes.forEach(node => this.processNodeForInvocations(node, m, id));
-            } catch (error) {
-                logger.error(`> WARNING: got exception ${error}. Continuing...`);
-            }
-        });
-    }
-
-    /**
-     * Builds a Famix model for an invocation of a method or a function
-     * @param n A node
-     * @param m A method or a function
-     * @param id The id of the method or the function
-     */
-    private processNodeForInvocations(n: Identifier, m: MethodDeclaration | ConstructorDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | FunctionDeclaration | FunctionExpression, id: number): void {
-        try {
-            this.famixFunctions.createFamixInvocation(n, m, id);
-
-            logger.debug(`node: node, (${n.getType().getText()})`);
-        } catch (error) {
-            logger.error(`> WARNING: got exception ${error}. ScopeDeclaration invalid for ${n.getSymbol().getFullyQualifiedName()}. Continuing...`);
-        }
-    }
-}