ts2famix 1.0.12 → 1.0.14

package/dist/analyze_functions/processInheritances.js

@@ -0,0 +1,73 @@
+"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;

package/dist/analyze_functions/processInvocations.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessInvocations = void 0;
+const ts_morph_1 = require("ts-morph");
+/**
+ * This class is used to build a Famix model for the invocations
+ */
+class ProcessInvocations {
+    /**
+     * Initializes the ProcessInvocations 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 invocations of the methods and functions of the source files
+     * @param methodsAndFunctionsWithId A map of methods and functions with their id
+     */
+    processInvocations(methodsAndFunctionsWithId) {
+        console.info(`Creating invocations:`);
+        methodsAndFunctionsWithId.forEach((m, id) => {
+            console.info(`Invocations to ${(m instanceof ts_morph_1.MethodDeclaration || m instanceof ts_morph_1.GetAccessorDeclaration || m instanceof ts_morph_1.SetAccessorDeclaration || m instanceof ts_morph_1.FunctionDeclaration) ? m.getName() : ((m instanceof ts_morph_1.ConstructorDeclaration) ? 'constructor' : (m.getName() ? m.getName() : 'anonymous'))}`);
+            try {
+                const temp_nodes = m.findReferencesAsNodes();
+                temp_nodes.forEach(node => this.processNodeForInvocations(node, m, id));
+            }
+            catch (error) {
+                console.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
+     */
+    processNodeForInvocations(n, m, id) {
+        try {
+            this.famixFunctions.createFamixInvocation(n, m, id);
+            console.info(`node: node, (${n.getType().getText()})`);
+        }
+        catch (error) {
+            console.error(`> WARNING: got exception ${error}. ScopeDeclaration invalid for ${n.getSymbol().getFullyQualifiedName()}. Continuing...`);
+        }
+    }
+}
+exports.ProcessInvocations = ProcessInvocations;

package/dist/famix2puml.js

@@ -0,0 +1,125 @@
+"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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = __importStar(require("fs"));
+const yargs_1 = __importDefault(require("yargs"));
+const argv = yargs_1.default
+    .example('ts-node src/famix2puml.ts -i JSONModels/projectName.json -o PUMLModels/projectName.puml', 'creates a PlantUML class diagram from a JSON-format model of a typescript project')
+    .alias('i', 'input')
+    .nargs('i', 1)
+    .alias('o', 'output')
+    .nargs('o', 1)
+    .demandOption('input').demandOption('output').parseSync();
+const INHERITANCE_LINK_COLOR = 'blue';
+const jsonFileName = argv.input;
+const pumlFileName = argv.output.substring(argv.output.indexOf("/") + 1, argv.output.lastIndexOf('.'));
+const parsedModel = JSON.parse(fs.readFileSync(jsonFileName, 'utf-8'));
+const classNameMap = new Map();
+const associations = new Array();
+// maps all class names to their id
+parsedModel.forEach(element => {
+    // map has id as key and unique (plantuml) class name
+    classNameMap.set(element.id, uniqueElementName(element));
+    const nameWithoutPrefix = element.FM3.split('.')[1];
+    // special case association
+    if (nameWithoutPrefix.endsWith('Inheritance')) {
+        const subclass = element['subclass'].ref;
+        const superclass = element['superclass'].ref;
+        associations.push({ from: subclass, to: superclass, name: nameWithoutPrefix });
+    }
+});
+// generates plantuml
+let plantUMLOutString = `@startuml ${pumlFileName}
+skinparam style strictuml
+title Object diagram for ${jsonFileName}
+`;
+parsedModel.forEach(element => {
+    plantUMLOutString += `${toPlantUML(element)}\n`;
+});
+// creates associations
+associations.forEach(association => {
+    // inheritance is a special case, show it in UML even though it doesn't make 100% sense in object diagrams
+    const isInheritance = association.name.startsWith('Inheritance');
+    if (isInheritance) {
+        plantUMLOutString += `${classNameMap.get(association.from)} --|> ${classNameMap.get(association.to)} #line:${INHERITANCE_LINK_COLOR}\n`;
+    }
+    else {
+        plantUMLOutString += `${classNameMap.get(association.from)} ..> "${association.name}" ${classNameMap.get(association.to)}\n`;
+    }
+});
+plantUMLOutString += '@enduml';
+// writes to output file
+fs.writeFile(argv.output, plantUMLOutString, (err) => {
+    if (err) {
+        throw err;
+    }
+});
+function uniqueElementName(element) {
+    return `${element.FM3}${element.id}`;
+}
+function toPlantUML(element) {
+    let plantUMLString = '';
+    const optionalName = element.name || '';
+    const nameWithoutPrefix = element.FM3.split('.')[1];
+    plantUMLString += `object "${optionalName}:${nameWithoutPrefix}" as ${uniqueElementName(element)} {\n`;
+    plantUMLString += `id = ${element.id}\n`;
+    plantUMLString += propertiesToPlantUML(element);
+    plantUMLString += '}\n';
+    return plantUMLString;
+}
+function propertiesToPlantUML(element) {
+    let plantUMLString = '';
+    for (const property in element) {
+        const attribute = element[property];
+        const isOneToManyReference = typeof attribute !== 'string' && attribute.length; // array but not a string
+        switch (property) {
+            // ignores these properties
+            case 'subclass':
+            case 'superclass':
+            case 'FM3':
+            case 'id':
+            case 'name':
+                break;
+            default:
+                if (isOneToManyReference) {
+                    attribute.forEach((composite, index) => {
+                        associations.push({ from: element.id, to: composite.ref, name: `${property}[${index}]` });
+                    });
+                }
+                else if (typeof attribute === 'object') {
+                    associations.push({ from: element.id, to: attribute.ref, name: property });
+                }
+                else { // typeof string, boolean, number, etc
+                    // treats it as a simple attribute
+                    plantUMLString += `${property} = ${element[property]}\n`;
+                }
+                break;
+        }
+    }
+    return plantUMLString;
+}