sol2uml 2.5.18 → 2.5.20

package/README.md

@@ -373,3 +373,5 @@ sol2uml uses [@solidity-parser/parser](https://github.com/solidity-parser/parser
 The [Solidity language grammar](https://solidity.readthedocs.io/en/develop/miscellaneous.html#language-grammar) is published with each major release.
 
 The diagrams are generated using [viz.js](https://github.com/mdaines/viz.js/) which uses [Graphviz](http://www.graphviz.org/) to render a [Scalable Vector Graphics (SVG)](https://en.wikipedia.org/wiki/Scalable_Vector_Graphics) file. [Graphviz Online](https://dreampuf.github.io/GraphvizOnline/) allows dot files to be edited and rendered into a SVG dynamically.
+
+The `diff` command use's Google's [Diff Match and Patch library](https://github.com/google/diff-match-patch).

package/lib/associations.js

@@ -13,42 +13,48 @@ const findAssociatedClass = (association, sourceUmlClass, umlClasses, searchedAb
     // If a link was found
     if (umlClass)
         return umlClass;
-    // Could not find a link so now need to recursively look at imports of imports
+    // Could not find association so now need to recursively look at imports of imports
     // add to already recursively processed files to avoid getting stuck in circular imports
     searchedAbsolutePaths.push(sourceUmlClass.absolutePath);
-    return findImplicitImport(association, sourceUmlClass, umlClasses, searchedAbsolutePaths);
+    const importedType = findChainedImport(association, sourceUmlClass, umlClasses, searchedAbsolutePaths);
+    if (importedType)
+        return importedType;
+    // Still could not find association so now need to recursively look for inherited types
+    const inheritedType = findInheritedType(association, sourceUmlClass, umlClasses);
+    if (inheritedType)
+        return inheritedType;
+    return undefined;
 };
 exports.findAssociatedClass = findAssociatedClass;
 // Tests if source class can be linked to the target class via an association
-const isAssociated = (association, sourceUmlClass, targetUmlClass, targetParentmlClass) => {
+const isAssociated = (association, sourceUmlClass, targetUmlClass, targetParentUmlClass) => {
     if (association.parentUmlClassName) {
         return (
         // class is in the same source file
         (association.targetUmlClassName === targetUmlClass.name &&
-            association.parentUmlClassName === targetParentmlClass?.name &&
+            association.parentUmlClassName === targetParentUmlClass?.name &&
             sourceUmlClass.absolutePath === targetUmlClass.absolutePath) ||
             // imported classes with no explicit import names
             (association.targetUmlClassName === targetUmlClass.name &&
-                association.parentUmlClassName === targetParentmlClass?.name &&
+                association.parentUmlClassName === targetParentUmlClass?.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.targetUmlClassName ===
+                    targetUmlClass.name &&
                     association.parentUmlClassName ===
                         importedClass.className &&
-                    importedClass.className ===
-                        targetUmlClass.name &&
                     importedClass.alias == undefined) ||
                     // If a parent contract with import alias
-                    (association.parentUmlClassName !== undefined &&
+                    (association.targetUmlClassName ===
+                        targetUmlClass.name &&
                         association.parentUmlClassName ===
-                            importedClass.alias &&
-                        importedClass.className ===
-                            targetUmlClass.name))));
+                            importedClass.alias))));
     }
+    // No parent class in the association
     return (
     // class is in the same source file
     (association.targetUmlClassName === targetUmlClass.name &&
@@ -70,11 +76,48 @@ const isAssociated = (association, sourceUmlClass, targetUmlClass, targetParentm
                     importedClass.alias &&
                     importedClass.className === targetUmlClass.name))));
 };
-const findImplicitImport = (association, sourceUmlClass, umlClasses, searchedRelativePaths) => {
-    // Get all implicit imports. That is, imports that do not explicitly import contracts or interfaces.
-    const implicitImports = sourceUmlClass.imports.filter((i) => i.classNames.length === 0);
-    // For each implicit import
-    for (const importDetail of implicitImports) {
+const findInheritedType = (association, sourceUmlClass, umlClasses) => {
+    // Get all realized associations.
+    const parentAssociations = sourceUmlClass.getParentContracts();
+    // For each parent association
+    for (const parentAssociation of parentAssociations) {
+        const parent = (0, exports.findAssociatedClass)(parentAssociation, sourceUmlClass, umlClasses);
+        if (!parent)
+            continue;
+        // For each struct on the parent
+        for (const structId of parent.structs) {
+            const structUmlClass = umlClasses.find((c) => c.id === structId);
+            if (!structUmlClass)
+                continue;
+            if (structUmlClass.name === association.targetUmlClassName) {
+                return structUmlClass;
+            }
+        }
+        // For each enum on the parent
+        for (const enumId of parent.enums) {
+            const enumUmlClass = umlClasses.find((c) => c.id === enumId);
+            if (!enumUmlClass)
+                continue;
+            if (enumUmlClass.name === association.targetUmlClassName) {
+                return enumUmlClass;
+            }
+        }
+        // Recursively look for inherited types
+        const targetClass = findInheritedType(association, parent, umlClasses);
+        if (targetClass)
+            return targetClass;
+    }
+    return undefined;
+};
+const findChainedImport = (association, sourceUmlClass, umlClasses, searchedRelativePaths) => {
+    // Get all valid imports. That is, imports that do not explicitly import contracts or interfaces
+    // or explicitly import the source class
+    const imports = sourceUmlClass.imports.filter((i) => i.classNames.length === 0 ||
+        i.classNames.some((cn) => (association.targetUmlClassName === cn.className &&
+            !cn.alias) ||
+            association.targetUmlClassName === cn.alias));
+    // For each import
+    for (const importDetail of imports) {
         // Find a class with the same absolute path as the import so we can get the new imports
         const newSourceUmlClass = umlClasses.find((c) => c.absolutePath === importDetail.absolutePath);
         if (!newSourceUmlClass) {
@@ -86,10 +129,18 @@ const findImplicitImport = (association, sourceUmlClass, umlClasses, searchedRel
             // Have already recursively looked for imports of imports in this file
             continue;
         }
-        // TODO need to handle imports that use aliases as the association will not be found
+        // find class linked to the association without aliased imports
         const umlClass = (0, exports.findAssociatedClass)(association, newSourceUmlClass, umlClasses, searchedRelativePaths);
         if (umlClass)
             return umlClass;
+        // find all aliased imports
+        const aliasedImports = importDetail.classNames.filter((cn) => cn.alias);
+        // For each aliased import
+        for (const aliasedImport of aliasedImports) {
+            const umlClass = (0, exports.findAssociatedClass)({ ...association, targetUmlClassName: aliasedImport.className }, newSourceUmlClass, umlClasses, searchedRelativePaths);
+            if (umlClass)
+                return umlClass;
+        }
     }
     return undefined;
 };

package/package.json

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