sol2uml 2.5.17 → 2.5.18

package/lib/associations.js

@@ -3,7 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findAssociatedClass = void 0;
 // Find the UML class linked to the association
 const findAssociatedClass = (association, sourceUmlClass, umlClasses, searchedAbsolutePaths = []) => {
-    const umlClass = umlClasses.find((targetUmlClass) => isAssociated(association, sourceUmlClass, targetUmlClass));
+    const umlClass = umlClasses.find((targetUmlClass) => {
+        const targetParentClass = association.parentUmlClassName &&
+            targetUmlClass.parentId !== undefined
+            ? umlClasses[targetUmlClass.parentId]
+            : undefined;
+        return isAssociated(association, sourceUmlClass, targetUmlClass, targetParentClass);
+    });
     // If a link was found
     if (umlClass)
         return umlClass;
@@ -14,18 +20,46 @@ const findAssociatedClass = (association, sourceUmlClass, umlClasses, searchedAb
 };
 exports.findAssociatedClass = findAssociatedClass;
 // Tests if source class can be linked to the target class via an association
-const isAssociated = (association, sourceUmlClass, targetUmlClass) => {
+const isAssociated = (association, sourceUmlClass, targetUmlClass, targetParentmlClass) => {
+    if (association.parentUmlClassName) {
+        return (
+        // class is in the same source file
+        (association.targetUmlClassName === targetUmlClass.name &&
+            association.parentUmlClassName === targetParentmlClass?.name &&
+            sourceUmlClass.absolutePath === targetUmlClass.absolutePath) ||
+            // imported classes with no explicit import names
+            (association.targetUmlClassName === targetUmlClass.name &&
+                association.parentUmlClassName === targetParentmlClass?.name &&
+                sourceUmlClass.imports.some((i) => i.absolutePath === targetUmlClass.absolutePath &&
+                    i.classNames.length === 0)) ||
+            // imported classes with explicit import names or import aliases
+            sourceUmlClass.imports.some((importLink) => importLink.absolutePath === targetUmlClass.absolutePath &&
+                importLink.classNames.some((importedClass) => 
+                // If a parent contract with no import alias
+                (association.parentUmlClassName !== undefined &&
+                    association.parentUmlClassName ===
+                        importedClass.className &&
+                    importedClass.className ===
+                        targetUmlClass.name &&
+                    importedClass.alias == undefined) ||
+                    // If a parent contract with import alias
+                    (association.parentUmlClassName !== undefined &&
+                        association.parentUmlClassName ===
+                            importedClass.alias &&
+                        importedClass.className ===
+                            targetUmlClass.name))));
+    }
     return (
     // class is in the same source file
     (association.targetUmlClassName === targetUmlClass.name &&
         sourceUmlClass.absolutePath === targetUmlClass.absolutePath) ||
         // imported classes with no explicit import names
         (association.targetUmlClassName === targetUmlClass.name &&
-            sourceUmlClass.imports.find((i) => i.absolutePath === targetUmlClass.absolutePath &&
+            sourceUmlClass.imports.some((i) => i.absolutePath === targetUmlClass.absolutePath &&
                 i.classNames.length === 0)) ||
         // imported classes with explicit import names or import aliases
-        sourceUmlClass.imports.find((i) => i.absolutePath === targetUmlClass.absolutePath &&
-            i.classNames.find((importedClass) => 
+        sourceUmlClass.imports.some((importLink) => importLink.absolutePath === targetUmlClass.absolutePath &&
+            importLink.classNames.some((importedClass) => 
             // no import alias
             (association.targetUmlClassName ===
                 importedClass.className &&

package/lib/converterAST2Classes.js

@@ -51,9 +51,9 @@ function convertAST2UmlClasses(node, relativePath, remappings, filesystem = fals
                         : relativePath,
                     relativePath,
                 });
+                umlClasses.push(umlClass);
                 parseContractDefinition(childNode, umlClass);
                 debug(`Added contract ${childNode.name}`);
-                umlClasses.push(umlClass);
             }
             else if (childNode.type === 'StructDefinition') {
                 debug(`Adding file level struct ${childNode.name}`);
@@ -349,6 +349,7 @@ function parseContractDefinition(node, umlClass) {
                 name: subNode.name,
                 absolutePath: umlClass.absolutePath,
                 relativePath: umlClass.relativePath,
+                parentId: umlClass.id,
                 stereotype: umlClass_1.ClassStereotype.Struct,
             });
             parseStructDefinition(subNode, structClass);
@@ -361,6 +362,7 @@ function parseContractDefinition(node, umlClass) {
                 name: subNode.name,
                 absolutePath: umlClass.absolutePath,
                 relativePath: umlClass.relativePath,
+                parentId: umlClass.id,
                 stereotype: umlClass_1.ClassStereotype.Enum,
             });
             parseEnumDefinition(subNode, enumClass);
@@ -397,6 +399,7 @@ function addAssociations(nodes, umlClass) {
                 }
                 if (node.typeName.type === 'UserDefinedTypeName') {
                     // Library references can have a Library dot variable notation. eg Set.Data
+                    // Structs and enums can also be under a library or contract
                     const { umlClassName, structOrEnum } = parseClassName(node.typeName.namePath);
                     umlClass.addAssociation({
                         referenceType,
@@ -405,6 +408,7 @@ function addAssociations(nodes, umlClass) {
                     if (structOrEnum) {
                         umlClass.addAssociation({
                             referenceType,
+                            parentUmlClassName: umlClassName,
                             targetUmlClassName: structOrEnum,
                         });
                     }

package/lib/converterClasses2Storage.js

@@ -131,7 +131,7 @@ const parseVariables = (umlClass, umlClasses, variables, storageSections, inheri
     newInheritedContracts.forEach((parent) => {
         const parentClass = (0, associations_1.findAssociatedClass)(parent, umlClass, umlClasses);
         if (!parentClass) {
-            throw Error(`Failed to find inherited contract "${parent.targetUmlClassName}" of "${umlClass.absolutePath}"`);
+            throw Error(`Failed to find inherited contract "${parent.targetUmlClassName}" sourced from "${umlClass.name}" with path "${umlClass.absolutePath}"`);
         }
         // recursively parse inherited contract
         parseVariables(parentClass, umlClasses, variables, storageSections, inheritedContracts, mapping, arrayItems, noExpandVariables);
@@ -438,10 +438,11 @@ const findTypeClass = (userType, attribute, umlClass, otherClasses) => {
     const association = {
         referenceType: umlClass_1.ReferenceType.Memory,
         targetUmlClassName: types.length === 1 ? types[0] : types[1],
+        parentUmlClassName: types.length === 1 ? undefined : types[0],
     };
     const typeClass = (0, associations_1.findAssociatedClass)(association, umlClass, otherClasses);
     if (!typeClass) {
-        throw Error(`Failed to find user defined type "${userType}" in attribute "${attribute.name}" of type "${attribute.attributeType}""`);
+        throw Error(`Failed to find user defined type "${userType}" in attribute "${attribute.name}" of from class "${umlClass.name}" with path "${umlClass.absolutePath}"`);
     }
     return typeClass;
 };

package/lib/parserFiles.js

@@ -16,8 +16,8 @@ const parseUmlClassesFromFiles = async (filesOrFolders, ignoreFilesOrFolders, su
     for (const file of files) {
         const node = await parseSolidityFile(file);
         const relativePath = (0, path_1.relative)(process.cwd(), file);
-        const umlClass = (0, converterAST2Classes_1.convertAST2UmlClasses)(node, relativePath, [], true);
-        umlClasses = umlClasses.concat(umlClass);
+        const newUmlClasses = (0, converterAST2Classes_1.convertAST2UmlClasses)(node, relativePath, [], true);
+        umlClasses = umlClasses.concat(newUmlClasses);
     }
     return umlClasses;
 };

package/lib/umlClass.d.ts

@@ -66,6 +66,7 @@ export declare enum ReferenceType {
 }
 export interface Association {
     referenceType: ReferenceType;
+    parentUmlClassName?: string;
     targetUmlClassName: string;
     realization?: boolean;
 }
@@ -78,6 +79,7 @@ export interface ClassProperties {
     name: string;
     absolutePath: string;
     relativePath: string;
+    parentId?: number;
     importedFileNames?: string[];
     stereotype?: ClassStereotype;
     enums?: number[];
@@ -95,6 +97,7 @@ export declare class UmlClass implements ClassProperties {
     name: string;
     absolutePath: string;
     relativePath: string;
+    parentId?: number;
     imports: Import[];
     stereotype?: ClassStereotype;
     constants: Constants[];

package/lib/umlClass.js

@@ -63,19 +63,15 @@ class UmlClass {
         if (!association || !association.targetUmlClassName) {
             throw TypeError(`Failed to add association. targetUmlClassName was missing`);
         }
-        // Will not duplicate lines to the same class and stereotype
-        // const targetUmlClass = `${association.targetUmlClassName}#${association.targetUmlClassStereotype}`
-        const targetUmlClass = association.targetUmlClassName;
         // If association doesn't already exist
-        if (!this.associations[targetUmlClass]) {
-            this.associations[targetUmlClass] = association;
+        if (!this.associations[association.targetUmlClassName]) {
+            this.associations[association.targetUmlClassName] = association;
         }
         // associate already exists
         else {
             // If new attribute reference type is Storage
             if (association.referenceType === ReferenceType.Storage) {
-                this.associations[targetUmlClass].referenceType =
-                    ReferenceType.Storage;
+                this.associations[association.targetUmlClassName].referenceType = ReferenceType.Storage;
             }
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sol2uml",
-  "version": "2.5.17",
+  "version": "2.5.18",
   "description": "Solidity contract visualisation tool.",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",