sol2uml 2.2.6 → 2.3.1

package/README.md

@@ -106,6 +106,8 @@ Options:
   -hi, --hideInterfaces            hide interfaces (default: false)
   -ha, --hideAbstracts             hide abstract contracts (default: false)
   -hn, --hideFilename              hide relative path and file name (default: false)
+  -s, --squash                     squash inherited contracts to the base contract(s) (default: false)
+  -hsc, --hideSourceContract       hide the source contract when using squash (default: false)
   -h, --help                       display help for command
 ```
 

package/lib/converterAST2Classes.d.ts

@@ -1,3 +1,10 @@
 import { ASTNode } from '@solidity-parser/parser/dist/src/ast-types';
 import { UmlClass } from './umlClass';
+/**
+ * Convert solidity parser output of type `ASTNode` to UML classes of type `UMLClass`
+ * @param node output of Solidity parser of type `ASTNode`
+ * @param relativePath relative path from the working directory to the Solidity source file
+ * @param filesystem flag if Solidity source code was parsed from the filesystem or Etherscan
+ * @return umlClasses array of UML class definitions of type `UmlClass`
+ */
 export declare function convertAST2UmlClasses(node: ASTNode, relativePath: string, filesystem?: boolean): UmlClass[];

package/lib/converterAST2Classes.js

@@ -29,7 +29,14 @@ const path_1 = require("path");
 const umlClass_1 = require("./umlClass");
 const typeGuards_1 = require("./typeGuards");
 const debug = require('debug')('sol2uml');
-let umlClasses = [];
+let umlClasses;
+/**
+ * Convert solidity parser output of type `ASTNode` to UML classes of type `UMLClass`
+ * @param node output of Solidity parser of type `ASTNode`
+ * @param relativePath relative path from the working directory to the Solidity source file
+ * @param filesystem flag if Solidity source code was parsed from the filesystem or Etherscan
+ * @return umlClasses array of UML class definitions of type `UmlClass`
+ */
 function convertAST2UmlClasses(node, relativePath, filesystem = false) {
     const imports = [];
     umlClasses = [];
@@ -43,7 +50,7 @@ function convertAST2UmlClasses(node, relativePath, filesystem = false) {
                         : relativePath,
                     relativePath,
                 });
-                umlClass = parseContractDefinition(umlClass, childNode);
+                parseContractDefinition(childNode, umlClass);
                 debug(`Added contract ${childNode.name}`);
                 umlClasses.push(umlClass);
             }
@@ -57,7 +64,7 @@ function convertAST2UmlClasses(node, relativePath, filesystem = false) {
                         : relativePath,
                     relativePath,
                 });
-                umlClass = parseStructDefinition(umlClass, childNode);
+                parseStructDefinition(childNode, umlClass);
                 debug(`Added struct ${umlClass.name}`);
                 umlClasses.push(umlClass);
             }
@@ -72,7 +79,7 @@ function convertAST2UmlClasses(node, relativePath, filesystem = false) {
                     relativePath,
                 });
                 debug(`Added enum ${umlClass.name}`);
-                umlClass = parseEnumDefinition(umlClass, childNode);
+                parseEnumDefinition(childNode, umlClass);
                 umlClasses.push(umlClass);
             }
             else if (childNode.type === 'ImportDirective') {
@@ -178,7 +185,12 @@ function convertAST2UmlClasses(node, relativePath, filesystem = false) {
     return umlClasses;
 }
 exports.convertAST2UmlClasses = convertAST2UmlClasses;
-function parseStructDefinition(umlClass, node) {
+/**
+ * Parse struct definition for UML attributes and associations.
+ * @param node defined in ASTNode as `StructDefinition`
+ * @param umlClass that has struct attributes and associations added. This parameter is mutated.
+ */
+function parseStructDefinition(node, umlClass) {
     node.members.forEach((member) => {
         const [type, attributeType] = parseTypeName(member.typeName);
         umlClass.attributes.push({
@@ -188,10 +200,14 @@ function parseStructDefinition(umlClass, node) {
         });
     });
     // Recursively parse struct members for associations
-    umlClass = addAssociations(node.members, umlClass);
-    return umlClass;
+    addAssociations(node.members, umlClass);
 }
-function parseEnumDefinition(umlClass, node) {
+/**
+ * Parse enum definition for UML attributes and associations.
+ * @param node defined in ASTNode as `EnumDefinition`
+ * @param umlClass that has enum attributes and associations added. This parameter is mutated.
+ */
+function parseEnumDefinition(node, umlClass) {
     let index = 0;
     node.members.forEach((member) => {
         umlClass.attributes.push({
@@ -200,10 +216,14 @@ function parseEnumDefinition(umlClass, node) {
         });
     });
     // Recursively parse struct members for associations
-    umlClass = addAssociations(node.members, umlClass);
-    return umlClass;
+    addAssociations(node.members, umlClass);
 }
-function parseContractDefinition(umlClass, node) {
+/**
+ * Parse contract definition for UML attributes, operations and associations.
+ * @param node defined in ASTNode as `ContractDefinition`
+ * @param umlClass that has attributes, operations and associations added. This parameter is mutated.
+ */
+function parseContractDefinition(node, umlClass) {
     umlClass.stereotype = parseContractKind(node.kind);
     // For each base contract
     node.baseContracts.forEach((baseClass) => {
@@ -239,7 +259,7 @@ function parseContractDefinition(umlClass, node) {
                 }
             });
             // Recursively parse variables for associations
-            umlClass = addAssociations(subNode.variables, umlClass);
+            addAssociations(subNode.variables, umlClass);
         }
         else if ((0, typeGuards_1.isUsingForDeclaration)(subNode)) {
             // Add association to library contract
@@ -262,7 +282,7 @@ function parseContractDefinition(umlClass, node) {
                     name: '',
                     stereotype: umlClass_1.OperatorStereotype.Fallback,
                     parameters: parseParameters(subNode.parameters),
-                    isPayable: parsePayable(subNode.stateMutability),
+                    stateMutability: subNode.stateMutability,
                 });
             }
             else {
@@ -283,9 +303,9 @@ function parseContractDefinition(umlClass, node) {
                 });
             }
             // Recursively parse function parameters for associations
-            umlClass = addAssociations(subNode.parameters, umlClass);
+            addAssociations(subNode.parameters, umlClass);
             if (subNode.returnParameters) {
-                umlClass = addAssociations(subNode.returnParameters, umlClass);
+                addAssociations(subNode.returnParameters, umlClass);
             }
             // If no body to the function, it must be either an Interface or Abstract
             if (subNode.body === null) {
@@ -296,7 +316,7 @@ function parseContractDefinition(umlClass, node) {
             }
             else {
                 // Recursively parse function statements for associations
-                umlClass = addAssociations(subNode.body.statements, umlClass);
+                addAssociations(subNode.body.statements, umlClass);
             }
         }
         else if ((0, typeGuards_1.isModifierDefinition)(subNode)) {
@@ -307,7 +327,7 @@ function parseContractDefinition(umlClass, node) {
             });
             if (subNode.body && subNode.body.statements) {
                 // Recursively parse modifier statements for associations
-                umlClass = addAssociations(subNode.body.statements, umlClass);
+                addAssociations(subNode.body.statements, umlClass);
             }
         }
         else if ((0, typeGuards_1.isEventDefinition)(subNode)) {
@@ -317,7 +337,7 @@ function parseContractDefinition(umlClass, node) {
                 parameters: parseParameters(subNode.parameters),
             });
             // Recursively parse event parameters for associations
-            umlClass = addAssociations(subNode.parameters, umlClass);
+            addAssociations(subNode.parameters, umlClass);
         }
         else if ((0, typeGuards_1.isStructDefinition)(subNode)) {
             const structClass = new umlClass_1.UmlClass({
@@ -326,7 +346,7 @@ function parseContractDefinition(umlClass, node) {
                 relativePath: umlClass.relativePath,
                 stereotype: umlClass_1.ClassStereotype.Struct,
             });
-            parseStructDefinition(structClass, subNode);
+            parseStructDefinition(subNode, structClass);
             umlClasses.push(structClass);
             // list as contract level struct
             umlClass.structs.push(structClass.id);
@@ -338,19 +358,22 @@ function parseContractDefinition(umlClass, node) {
                 relativePath: umlClass.relativePath,
                 stereotype: umlClass_1.ClassStereotype.Enum,
             });
-            parseEnumDefinition(enumClass, subNode);
+            parseEnumDefinition(subNode, enumClass);
             umlClasses.push(enumClass);
             // list as contract level enum
             umlClass.enums.push(enumClass.id);
         }
     });
-    return umlClass;
 }
-// Recursively parse AST nodes for associations
+/**
+ * Recursively parse a list of ASTNodes for UML associations
+ * @param nodes array of parser output of type ASTNode
+ * @param umlClass that has associations added of type `Association`. This parameter is mutated.
+ */
 function addAssociations(nodes, umlClass) {
     if (!nodes || !Array.isArray(nodes)) {
         debug('Warning - can not recursively parse AST nodes for associations. Invalid nodes array');
-        return umlClass;
+        return;
     }
     for (const node of nodes) {
         // Some variables can be null. eg var (lad,,,) = tub.cups(cup);
@@ -382,8 +405,8 @@ function addAssociations(nodes, umlClass) {
                     }
                 }
                 else if (node.typeName.type === 'Mapping') {
-                    umlClass = addAssociations([node.typeName.keyType], umlClass);
-                    umlClass = addAssociations([
+                    addAssociations([node.typeName.keyType], umlClass);
+                    addAssociations([
                         {
                             ...node.typeName.valueType,
                             isStateVar: node.isStateVar,
@@ -416,89 +439,101 @@ function addAssociations(nodes, umlClass) {
                 });
                 break;
             case 'Block':
-                umlClass = addAssociations(node.statements, umlClass);
+                addAssociations(node.statements, umlClass);
                 break;
             case 'StateVariableDeclaration':
             case 'VariableDeclarationStatement':
-                umlClass = addAssociations(node.variables, umlClass);
-                umlClass = parseExpression(node.initialValue, umlClass);
+                addAssociations(node.variables, umlClass);
+                parseExpression(node.initialValue, umlClass);
+                break;
+            case 'EmitStatement':
+                addAssociations(node.eventCall.arguments, umlClass);
+                parseExpression(node.eventCall.expression, umlClass);
+                break;
+            case 'FunctionCall':
+                addAssociations(node.arguments, umlClass);
+                parseExpression(node.expression, umlClass);
                 break;
             case 'ForStatement':
                 if ('statements' in node.body) {
-                    umlClass = addAssociations(node.body.statements, umlClass);
+                    addAssociations(node.body.statements, umlClass);
                 }
-                umlClass = parseExpression(node.conditionExpression, umlClass);
-                umlClass = parseExpression(node.loopExpression.expression, umlClass);
+                parseExpression(node.conditionExpression, umlClass);
+                parseExpression(node.loopExpression.expression, umlClass);
                 break;
             case 'WhileStatement':
                 if ('statements' in node.body) {
-                    umlClass = addAssociations(node.body.statements, umlClass);
+                    addAssociations(node.body.statements, umlClass);
                 }
                 break;
             case 'DoWhileStatement':
                 if ('statements' in node.body) {
-                    umlClass = addAssociations(node.body.statements, umlClass);
+                    addAssociations(node.body.statements, umlClass);
                 }
-                umlClass = parseExpression(node.condition, umlClass);
+                parseExpression(node.condition, umlClass);
                 break;
             case 'ReturnStatement':
             case 'ExpressionStatement':
-                umlClass = parseExpression(node.expression, umlClass);
+                parseExpression(node.expression, umlClass);
                 break;
             case 'IfStatement':
                 if (node.trueBody) {
                     if ('statements' in node.trueBody) {
-                        umlClass = addAssociations(node.trueBody.statements, umlClass);
+                        addAssociations(node.trueBody.statements, umlClass);
                     }
                     if ('expression' in node.trueBody) {
-                        umlClass = parseExpression(node.trueBody.expression, umlClass);
+                        parseExpression(node.trueBody.expression, umlClass);
                     }
                 }
                 if (node.falseBody) {
                     if ('statements' in node.falseBody) {
-                        umlClass = addAssociations(node.falseBody.statements, umlClass);
+                        addAssociations(node.falseBody.statements, umlClass);
                     }
                     if ('expression' in node.falseBody) {
-                        umlClass = parseExpression(node.falseBody.expression, umlClass);
+                        parseExpression(node.falseBody.expression, umlClass);
                     }
                 }
-                umlClass = parseExpression(node.condition, umlClass);
+                parseExpression(node.condition, umlClass);
                 break;
             default:
                 break;
         }
     }
-    return umlClass;
 }
+/**
+ * Recursively parse an expression to add UML associations to other contracts, constants, enums or structs.
+ * @param expression defined in ASTNode as `Expression`
+ * @param umlClass that has associations added of type `Association`. This parameter is mutated.
+ */
 function parseExpression(expression, umlClass) {
     if (!expression || !expression.type) {
-        return umlClass;
+        return;
     }
     if (expression.type === 'BinaryOperation') {
-        umlClass = parseExpression(expression.left, umlClass);
-        umlClass = parseExpression(expression.right, umlClass);
+        parseExpression(expression.left, umlClass);
+        parseExpression(expression.right, umlClass);
     }
     else if (expression.type === 'FunctionCall') {
-        umlClass = parseExpression(expression.expression, umlClass);
+        parseExpression(expression.expression, umlClass);
         expression.arguments.forEach((arg) => {
-            umlClass = parseExpression(arg, umlClass);
+            parseExpression(arg, umlClass);
         });
     }
     else if (expression.type === 'IndexAccess') {
-        umlClass = parseExpression(expression.base, umlClass);
-        umlClass = parseExpression(expression.index, umlClass);
+        parseExpression(expression.base, umlClass);
+        parseExpression(expression.index, umlClass);
     }
     else if (expression.type === 'TupleExpression') {
         expression.components.forEach((component) => {
-            umlClass = parseExpression(component, umlClass);
+            parseExpression(component, umlClass);
         });
     }
     else if (expression.type === 'MemberAccess') {
-        umlClass = parseExpression(expression.expression, umlClass);
+        parseExpression(expression.expression, umlClass);
     }
     else if (expression.type === 'Conditional') {
-        umlClass = addAssociations([expression.trueExpression], umlClass);
-        umlClass = addAssociations([expression.falseExpression], umlClass);
+        addAssociations([expression.trueExpression], umlClass);
+        addAssociations([expression.falseExpression], umlClass);
     }
     else if (expression.type === 'Identifier') {
         umlClass.addAssociation({
@@ -507,14 +542,19 @@ function parseExpression(expression, umlClass) {
         });
     }
     else if (expression.type === 'NewExpression') {
-        umlClass = addAssociations([expression.typeName], umlClass);
+        addAssociations([expression.typeName], umlClass);
     }
     else if (expression.type === 'UnaryOperation' &&
         expression.subExpression) {
-        umlClass = parseExpression(expression.subExpression, umlClass);
+        parseExpression(expression.subExpression, umlClass);
     }
-    return umlClass;
 }
+/**
+ * Convert user defined type to class name and struct or enum.
+ * eg `Set.Data` has class `Set` and struct or enum of `Data`
+ * @param rawClassName can be `TypeName` properties `namePath`, `length.name` or `baseTypeName.namePath` as defined in the ASTNode
+ * @return object with `umlClassName` and `structOrEnum` of type string
+ */
 function parseClassName(rawClassName) {
     if (!rawClassName ||
         typeof rawClassName !== 'string' ||
@@ -531,6 +571,11 @@ function parseClassName(rawClassName) {
         structOrEnum: splitUmlClassName[1],
     };
 }
+/**
+ * Converts the contract visibility to attribute or operator visibility of type `Visibility`
+ * @param params defined in ASTNode as VariableDeclaration.visibility, FunctionDefinition.visibility or FunctionTypeName.visibility
+ * @return visibility `Visibility` enum used by the `visibility` property on UML `Attribute` or `Operator`
+ */
 function parseVisibility(visibility) {
     switch (visibility) {
         case 'default':
@@ -547,6 +592,12 @@ function parseVisibility(visibility) {
             throw Error(`Invalid visibility ${visibility}. Was not public, external, internal or private`);
     }
 }
+/**
+ * Recursively converts contract variables to UMLClass attribute types.
+ * Types can be standard Solidity types, arrays, mappings or user defined types like structs and enums.
+ * @param typeName defined in ASTNode as `TypeName`
+ * @return attributeTypes array of type string and `AttributeType`
+ */
 function parseTypeName(typeName) {
     switch (typeName.type) {
         case 'ElementaryTypeName':
@@ -582,6 +633,11 @@ function parseTypeName(typeName) {
             throw Error(`Invalid typeName ${typeName}`);
     }
 }
+/**
+ * Converts the contract params to `Operator` properties `parameters` or `returnParameters`
+ * @param params defined in ASTNode as `VariableDeclaration`
+ * @return parameters or `returnParameters` of the `Operator` of type `Parameter`
+ */
 function parseParameters(params) {
     if (!params || !params) {
         return [];
@@ -596,6 +652,11 @@ function parseParameters(params) {
     }
     return parameters;
 }
+/**
+ * Converts the contract `kind` to `UMLClass` stereotype
+ * @param kind defined in ASTNode as ContractDefinition.kind
+ * @return stereotype of the `UMLClass` with type `ClassStereotype
+ */
 function parseContractKind(kind) {
     switch (kind) {
         case 'contract':
@@ -610,7 +671,4 @@ function parseContractKind(kind) {
             throw Error(`Invalid kind ${kind}`);
     }
 }
-function parsePayable(stateMutability) {
-    return stateMutability === 'payable';
-}
 //# sourceMappingURL=converterAST2Classes.js.map

package/lib/converterClass2Dot.d.ts

@@ -12,5 +12,6 @@ export interface ClassOptions {
     hidePrivates?: boolean;
     hideAbstracts?: boolean;
     hideFilename?: boolean;
+    hideSourceContract?: boolean;
 }
 export declare const convertClass2Dot: (umlClass: UmlClass, options?: ClassOptions) => string;

package/lib/converterClass2Dot.js

@@ -71,7 +71,8 @@ const dotAttributeVisibilities = (umlClass, options) => {
     if (umlClass.stereotype === umlClass_1.ClassStereotype.Struct ||
         umlClass.stereotype === umlClass_1.ClassStereotype.Enum ||
         umlClass.stereotype === umlClass_1.ClassStereotype.Constant) {
-        return dotString + dotAttributes(umlClass.attributes, undefined, false);
+        return (dotString +
+            dotAttributes(umlClass.attributes, options, undefined, false));
     }
     // For each visibility group
     for (const vizGroup of ['Private', 'Internal', 'External', 'Public']) {
@@ -100,11 +101,11 @@ const dotAttributeVisibilities = (umlClass, options) => {
                 attributes.push(attribute);
             }
         }
-        dotString += dotAttributes(attributes, vizGroup);
+        dotString += dotAttributes(attributes, options, vizGroup);
     }
     return dotString;
 };
-const dotAttributes = (attributes, vizGroup, indent = true) => {
+const dotAttributes = (attributes, options, vizGroup, indent = true) => {
     if (!attributes || attributes.length === 0) {
         return '';
     }
@@ -112,7 +113,10 @@ const dotAttributes = (attributes, vizGroup, indent = true) => {
     let dotString = vizGroup ? vizGroup + ':\\l' : '';
     // for each attribute
     attributes.forEach((attribute) => {
-        dotString += `${indentString}${attribute.name}: ${attribute.type}\\l`;
+        const sourceContract = attribute.sourceContract && !options.hideSourceContract
+            ? ` \\<\\<${attribute.sourceContract}\\>\\>`
+            : '';
+        dotString += `${indentString}${attribute.name}: ${attribute.type}${sourceContract}\\l`;
     });
     return dotString;
 };
@@ -179,6 +183,8 @@ const dotOperators = (umlClass, vizGroup, operators, options) => {
         if (options.hideModifiers === false && operator.modifiers?.length > 0) {
             dotString += ` \\<\\<${operator.modifiers.join(', ')}\\>\\>`;
         }
+        if (operator.sourceContract && !options.hideSourceContract)
+            dotString += ` \\<\\<${operator.sourceContract}\\>\\>`;
         dotString += '\\l';
     }
     return dotString;

package/lib/converterClasses2Dot.d.ts

@@ -1,4 +1,12 @@
 import { ClassOptions } from './converterClass2Dot';
 import { UmlClass } from './umlClass';
+/**
+ * Converts UML classes to Graphviz's DOT format.
+ * The DOT grammar defines Graphviz nodes, edges, graphs, subgraphs, and clusters http://www.graphviz.org/doc/info/lang.html
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param clusterFolders flag if UML classes are to be clustered into folders their source code was in
+ * @param classOptions command line options for the `class` command
+ * @return dotString Graphviz's DOT format for defining nodes, edges and clusters.
+ */
 export declare function convertUmlClasses2Dot(umlClasses: UmlClass[], clusterFolders?: boolean, classOptions?: ClassOptions): string;
 export declare function addAssociationsToDot(umlClasses: UmlClass[], classOptions?: ClassOptions): string;

package/lib/converterClasses2Dot.js

@@ -6,6 +6,14 @@ const converterClass2Dot_1 = require("./converterClass2Dot");
 const umlClass_1 = require("./umlClass");
 const associations_1 = require("./associations");
 const debug = require('debug')('sol2uml');
+/**
+ * Converts UML classes to Graphviz's DOT format.
+ * The DOT grammar defines Graphviz nodes, edges, graphs, subgraphs, and clusters http://www.graphviz.org/doc/info/lang.html
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param clusterFolders flag if UML classes are to be clustered into folders their source code was in
+ * @param classOptions command line options for the `class` command
+ * @return dotString Graphviz's DOT format for defining nodes, edges and clusters.
+ */
 function convertUmlClasses2Dot(umlClasses, clusterFolders = false, classOptions = {}) {
     let dotString = `
 digraph UmlClassDiagram {

package/lib/filterClasses.d.ts

@@ -1,6 +1,31 @@
 import { WeightedDiGraph } from 'js-graph-algorithms';
 import { UmlClass } from './umlClass';
+import { ClassOptions } from './converterClass2Dot';
+/**
+ * Filter out any UML Class types that are to be hidden.
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param options sol2uml class options
+ * @return umlClasses filtered list of UML classes of type `UMLClass`
+ */
+export declare const filterHiddenClasses: (umlClasses: UmlClass[], options: ClassOptions) => UmlClass[];
+/**
+ * Finds all the UML classes that have an association with a list of base contract names.
+ * The associated classes can be contracts, abstract contracts, interfaces, libraries, enums, structs or constants.
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param baseContractNames array of base contract names
+ * @param depth limit the number of associations from the base contract.
+ * @return filteredUmlClasses list of UML classes of type `UMLClass`
+ */
 export declare const classesConnectedToBaseContracts: (umlClasses: UmlClass[], baseContractNames: string[], depth?: number) => UmlClass[];
+/**
+ * Finds all the UML classes that have an association with a base contract name.
+ * The associated classes can be contracts, abstract contracts, interfaces, libraries, enums, structs or constants.
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param baseContractName base contract name
+ * @param weightedDirectedGraph graph of type WeightedDiGraph from the `js-graph-algorithms` package
+ * @param depth limit the number of associations from the base contract.
+ * @return filteredUmlClasses list of UML classes of type `UMLClass`
+ */
 export declare const classesConnectedToBaseContract: (umlClasses: UmlClass[], baseContractName: string, weightedDirectedGraph: WeightedDiGraph, depth?: number) => {
     [contractName: string]: UmlClass;
 };

package/lib/filterClasses.js

@@ -1,8 +1,38 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.topologicalSortClasses = exports.classesConnectedToBaseContract = exports.classesConnectedToBaseContracts = void 0;
+exports.topologicalSortClasses = exports.classesConnectedToBaseContract = exports.classesConnectedToBaseContracts = exports.filterHiddenClasses = void 0;
 const js_graph_algorithms_1 = require("js-graph-algorithms");
+const umlClass_1 = require("./umlClass");
 const associations_1 = require("./associations");
+/**
+ * Filter out any UML Class types that are to be hidden.
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param options sol2uml class options
+ * @return umlClasses filtered list of UML classes of type `UMLClass`
+ */
+const filterHiddenClasses = (umlClasses, options) => {
+    return umlClasses.filter((u) => (u.stereotype === umlClass_1.ClassStereotype.Enum && !options.hideEnums) ||
+        (u.stereotype === umlClass_1.ClassStereotype.Struct && !options.hideStructs) ||
+        (u.stereotype === umlClass_1.ClassStereotype.Abstract &&
+            !options.hideAbstracts) ||
+        (u.stereotype === umlClass_1.ClassStereotype.Interface &&
+            !options.hideInterfaces) ||
+        (u.stereotype === umlClass_1.ClassStereotype.Constant &&
+            !options.hideConstants) ||
+        (u.stereotype === umlClass_1.ClassStereotype.Library &&
+            !options.hideLibraries) ||
+        u.stereotype === umlClass_1.ClassStereotype.None ||
+        u.stereotype === umlClass_1.ClassStereotype.Contract);
+};
+exports.filterHiddenClasses = filterHiddenClasses;
+/**
+ * Finds all the UML classes that have an association with a list of base contract names.
+ * The associated classes can be contracts, abstract contracts, interfaces, libraries, enums, structs or constants.
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param baseContractNames array of base contract names
+ * @param depth limit the number of associations from the base contract.
+ * @return filteredUmlClasses list of UML classes of type `UMLClass`
+ */
 const classesConnectedToBaseContracts = (umlClasses, baseContractNames, depth) => {
     let filteredUmlClasses = {};
     const weightedDirectedGraph = loadWeightedDirectedGraph(umlClasses);
@@ -15,6 +45,15 @@ const classesConnectedToBaseContracts = (umlClasses, baseContractNames, depth) =
     return Object.values(filteredUmlClasses);
 };
 exports.classesConnectedToBaseContracts = classesConnectedToBaseContracts;
+/**
+ * Finds all the UML classes that have an association with a base contract name.
+ * The associated classes can be contracts, abstract contracts, interfaces, libraries, enums, structs or constants.
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param baseContractName base contract name
+ * @param weightedDirectedGraph graph of type WeightedDiGraph from the `js-graph-algorithms` package
+ * @param depth limit the number of associations from the base contract.
+ * @return filteredUmlClasses list of UML classes of type `UMLClass`
+ */
 const classesConnectedToBaseContract = (umlClasses, baseContractName, weightedDirectedGraph, depth = 1000) => {
     // Find the base UML Class from the base contract name
     const baseUmlClass = umlClasses.find(({ name }) => {
@@ -35,7 +74,9 @@ const classesConnectedToBaseContract = (umlClasses, baseContractName, weightedDi
 };
 exports.classesConnectedToBaseContract = classesConnectedToBaseContract;
 function loadWeightedDirectedGraph(umlClasses) {
-    const weightedDirectedGraph = new js_graph_algorithms_1.WeightedDiGraph(umlClasses.length); // the number vertices in the graph
+    const weightedDirectedGraph = new js_graph_algorithms_1.WeightedDiGraph(
+    // the number vertices in the graph
+    umlClass_1.UmlClass.idCounter + 1);
     for (const sourceUmlClass of umlClasses) {
         for (const association of Object.values(sourceUmlClass.associations)) {
             // Find the first UML Class that matches the target class name
@@ -43,6 +84,8 @@ function loadWeightedDirectedGraph(umlClasses) {
             if (!targetUmlClass) {
                 continue;
             }
+            const isTarget = umlClasses.find((u) => u.id === targetUmlClass.id);
+            console.log(`isTarget ${isTarget} Adding edge from ${sourceUmlClass.name} with id ${sourceUmlClass.id} to ${targetUmlClass.name} with id ${targetUmlClass.id} and type ${targetUmlClass.stereotype}`);
             weightedDirectedGraph.addEdge(new js_graph_algorithms_1.Edge(sourceUmlClass.id, targetUmlClass.id, 1));
         }
     }

package/lib/parserEtherscan.d.ts

@@ -1,7 +1,7 @@
 import { ASTNode } from '@solidity-parser/parser/dist/src/ast-types';
 import { UmlClass } from './umlClass';
 export declare const networks: readonly ["mainnet", "ropsten", "kovan", "rinkeby", "goerli", "sepolia", "polygon", "testnet.polygon", "arbitrum", "testnet.arbitrum", "avalanche", "testnet.avalanche", "bsc", "testnet.bsc", "crono", "fantom", "testnet.fantom", "moonbeam", "optimistic", "kovan-optimistic", "gnosisscan"];
-declare type Network = typeof networks[number];
+export type Network = typeof networks[number];
 export declare class EtherscanParser {
     protected apikey: string;
     network: Network;
@@ -45,4 +45,3 @@ export declare class EtherscanParser {
         compilerVersion: string;
     }>;
 }
-export {};

package/lib/parserGeneral.d.ts

@@ -1,5 +1,17 @@
+import { Network } from './parserEtherscan';
 import { UmlClass } from './umlClass';
-export declare const parserUmlClasses: (fileFolderAddress: string, options: any) => Promise<{
+export interface ParserOptions {
+    apiKey?: string;
+    network?: Network;
+    subfolders?: string;
+    ignoreFilesOrFolders?: string;
+}
+/**
+ * Parses Solidity source code from a local filesystem or verified code on Etherscan
+ * @param fileFolderAddress filename, folder name or contract address
+ * @param options of type `ParserOptions`
+ */
+export declare const parserUmlClasses: (fileFolderAddress: string, options: ParserOptions) => Promise<{
     umlClasses: UmlClass[];
     contractName?: string;
 }>;

package/lib/parserGeneral.js

@@ -5,6 +5,11 @@ const parserEtherscan_1 = require("./parserEtherscan");
 const parserFiles_1 = require("./parserFiles");
 const regEx_1 = require("./utils/regEx");
 const debug = require('debug')('sol2uml');
+/**
+ * Parses Solidity source code from a local filesystem or verified code on Etherscan
+ * @param fileFolderAddress filename, folder name or contract address
+ * @param options of type `ParserOptions`
+ */
 const parserUmlClasses = async (fileFolderAddress, options) => {
     let result = {
         umlClasses: [],

package/lib/sol2uml.js

@@ -11,6 +11,7 @@ const converterStorage2Dot_1 = require("./converterStorage2Dot");
 const regEx_1 = require("./utils/regEx");
 const writerFiles_1 = require("./writerFiles");
 const path_1 = require("path");
+const squashClasses_1 = require("./squashClasses");
 const program = new commander_1.Command();
 const version = (0, path_1.basename)(__dirname) === 'lib'
     ? require('../package.json').version // used when run from compile js in /lib
@@ -69,20 +70,36 @@ If an Ethereum address with a 0x prefix is passed, the verified source code from
     .option('-hi, --hideInterfaces', 'hide interfaces', false)
     .option('-ha, --hideAbstracts', 'hide abstract contracts', false)
     .option('-hn, --hideFilename', 'hide relative path and file name', false)
+    .option('-s, --squash', 'squash inherited contracts to the base contract(s)', false)
+    .option('-hsc, --hideSourceContract', 'hide the source contract when using squash', false)
     .action(async (fileFolderAddress, options, command) => {
     try {
         const combinedOptions = {
             ...command.parent._optionValues,
             ...options,
         };
+        // Parse Solidity code from local file system or verified source code on Etherscan.
         let { umlClasses, contractName } = await (0, parserGeneral_1.parserUmlClasses)(fileFolderAddress, combinedOptions);
-        let filteredUmlClasses = umlClasses;
-        if (options.baseContractNames) {
-            const baseContractNames = options.baseContractNames.split(',');
-            filteredUmlClasses = (0, filterClasses_1.classesConnectedToBaseContracts)(umlClasses, baseContractNames, options.depth);
+        if (options.squash &&
+            // Must specify base contract(s) or parse from Etherscan to get contractName
+            !(options.baseContractNames || contractName)) {
+            throw Error('Must specify base contract(s) when using the squash option against local Solidity files.');
+        }
+        // Filter out any class stereotypes that are to be hidden
+        let filteredUmlClasses = (0, filterClasses_1.filterHiddenClasses)(umlClasses, options);
+        const baseContractNames = options.baseContractNames?.split(',');
+        if (baseContractNames) {
+            // Find all the classes connected to the base classes
+            filteredUmlClasses = (0, filterClasses_1.classesConnectedToBaseContracts)(filteredUmlClasses, baseContractNames, options.depth);
             contractName = baseContractNames[0];
         }
+        // squash contracts
+        if (options.squash) {
+            filteredUmlClasses = (0, squashClasses_1.squashUmlClasses)(filteredUmlClasses, baseContractNames || [contractName]);
+        }
+        // Convert UML classes to Graphviz dot format.
         const dotString = (0, converterClasses2Dot_1.convertUmlClasses2Dot)(filteredUmlClasses, combinedOptions.clusterFolders, combinedOptions);
+        // Convert Graphviz dot format to file formats. eg svg or png
         await (0, writerFiles_1.writeOutputFiles)(dotString, fileFolderAddress, contractName || 'classDiagram', combinedOptions.outputFormat, combinedOptions.outputFileName);
         debug(`Finished generating UML`);
     }

package/lib/squashClasses.d.ts

@@ -0,0 +1,8 @@
+import { UmlClass } from './umlClass';
+/**
+ * Flattens the inheritance hierarchy for each base contract.
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param baseContractNames array of contract names to be rendered in squashed format.
+ * @return squashUmlClasses array of UML classes of type `UMLClass`
+ */
+export declare const squashUmlClasses: (umlClasses: UmlClass[], baseContractNames: string[]) => UmlClass[];

package/lib/squashClasses.js

@@ -0,0 +1,149 @@
+"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.squashUmlClasses = void 0;
+const umlClass_1 = require("./umlClass");
+const crypto = __importStar(require("crypto"));
+const debug = require('debug')('sol2uml');
+/**
+ * Flattens the inheritance hierarchy for each base contract.
+ * @param umlClasses array of UML classes of type `UMLClass`
+ * @param baseContractNames array of contract names to be rendered in squashed format.
+ * @return squashUmlClasses array of UML classes of type `UMLClass`
+ */
+const squashUmlClasses = (umlClasses, baseContractNames) => {
+    let removedClassIds = [];
+    for (const baseContractName of baseContractNames) {
+        // Find the base UML Class to squash
+        let baseIndex = umlClasses.findIndex(({ name }) => {
+            return name === baseContractName;
+        });
+        if (baseIndex === undefined) {
+            throw Error(`Failed to find contract with name "${baseContractName}" to squash`);
+        }
+        const baseClass = umlClasses[baseIndex];
+        let squashedClass = new umlClass_1.UmlClass({
+            name: baseClass.name,
+            absolutePath: baseClass.absolutePath,
+            relativePath: baseClass.relativePath,
+        });
+        squashedClass.id = baseClass.id;
+        const result = recursiveSquash(squashedClass, [], baseClass, umlClasses, 1);
+        removedClassIds = removedClassIds.concat(result.removedClassIds);
+        // Remove overridden functions from squashed class
+        squashedClass.operators = reduceOperators(squashedClass.operators);
+        umlClasses[baseIndex] = squashedClass;
+    }
+    // filter the list of classes that will be rendered
+    return umlClasses.filter((u) => 
+    // remove any squashed inherited contracts
+    !removedClassIds.includes(u.id) ||
+        // Include all base contracts
+        baseContractNames.includes(u.name));
+};
+exports.squashUmlClasses = squashUmlClasses;
+const recursiveSquash = (squashedClass, inheritedContractNames, baseClass, umlClasses, startPosition) => {
+    let currentPosition = startPosition;
+    const removedClassIds = [];
+    // For each association from the baseClass
+    for (const [targetClassName, association] of Object.entries(baseClass.associations)) {
+        // if inheritance and (Abstract or Contract)
+        // Libraries and Interfaces will be copied
+        if (association.realization) {
+            // Find the target UML Class
+            const inheritedContract = umlClasses.find(({ name }) => {
+                return name === targetClassName;
+            });
+            if (!inheritedContract) {
+                debug(`Warning: failed to find inherited contract with name ${targetClassName}`);
+                continue;
+            }
+            // Is the associated class a contract or abstract contract?
+            if (inheritedContract?.stereotype === umlClass_1.ClassStereotype.Library) {
+                squashedClass.addAssociation(association);
+            }
+            else {
+                // has the contract already been added to the inheritance tree?
+                const alreadyInherited = inheritedContractNames.includes(inheritedContract.name);
+                // Do not add inherited contract if it has already been added to the inheritance tree
+                if (!alreadyInherited) {
+                    inheritedContractNames.push(inheritedContract.name);
+                    const squashResult = recursiveSquash(squashedClass, inheritedContractNames, inheritedContract, umlClasses, currentPosition++);
+                    // Add to list of removed class ids
+                    removedClassIds.push(...squashResult.removedClassIds, inheritedContract.id);
+                }
+            }
+        }
+        else {
+            // Copy association but will not duplicate it
+            squashedClass.addAssociation(association);
+        }
+    }
+    // Copy class properties from the baseClass to the squashedClass
+    baseClass.constants.forEach((c) => squashedClass.constants.push({ ...c, sourceContract: baseClass.name }));
+    baseClass.attributes.forEach((a) => squashedClass.attributes.push({ ...a, sourceContract: baseClass.name }));
+    baseClass.enums.forEach((e) => squashedClass.enums.push(e));
+    baseClass.structs.forEach((s) => squashedClass.structs.push(s));
+    baseClass.imports.forEach((i) => squashedClass.imports.push(i));
+    // copy the functions
+    baseClass.operators.forEach((f) => squashedClass.operators.push({
+        ...f,
+        hash: hash(f),
+        inheritancePosition: currentPosition,
+        sourceContract: baseClass.name,
+    }));
+    return {
+        currentPosition,
+        removedClassIds,
+    };
+};
+const hash = (operator) => {
+    const hash = crypto.createHash('sha256');
+    let data = operator.name ?? 'fallback';
+    operator.parameters?.forEach((p) => {
+        data += ',' + p.type;
+    });
+    operator.returnParameters?.forEach((p) => {
+        data += ',' + p.type;
+    });
+    return hash.update(data).digest('hex');
+};
+const reduceOperators = (operators) => {
+    const hashes = new Set(operators.map((o) => o.hash));
+    const operatorsWithNoHash = operators.filter((o) => !o.hash);
+    const newOperators = [];
+    for (const hash of hashes) {
+        const operator = operators
+            .filter((o) => o.hash === hash)
+            // sort operators by inheritance position. smaller to highest
+            .sort((o) => o.inheritancePosition)
+            // get last operator in the array
+            .slice(-1)[0];
+        newOperators.push(operator);
+    }
+    newOperators.push(...operatorsWithNoHash);
+    return newOperators;
+};
+//# sourceMappingURL=squashClasses.js.map

package/lib/umlClass.d.ts

@@ -44,6 +44,7 @@ export interface Attribute {
     type?: string;
     attributeType?: AttributeType;
     compiled?: boolean;
+    sourceContract?: string;
 }
 export interface Parameter {
     name?: string;
@@ -53,8 +54,11 @@ export interface Operator extends Attribute {
     stereotype?: OperatorStereotype;
     parameters?: Parameter[];
     returnParameters?: Parameter[];
-    isPayable?: boolean;
+    stateMutability?: string;
     modifiers?: string[];
+    hash?: string;
+    inheritancePosition?: number;
+    sourceContract?: string;
 }
 export declare enum ReferenceType {
     Memory = 0,
@@ -63,12 +67,12 @@ export declare enum ReferenceType {
 export interface Association {
     referenceType: ReferenceType;
     targetUmlClassName: string;
-    targetUmlClassStereotype?: ClassStereotype;
     realization?: boolean;
 }
 export interface Constants {
     name: string;
     value: number;
+    sourceContract?: string;
 }
 export interface ClassProperties {
     name: string;

package/lib/umlClass.js

@@ -45,6 +45,7 @@ var ReferenceType;
 })(ReferenceType = exports.ReferenceType || (exports.ReferenceType = {}));
 class UmlClass {
     constructor(properties) {
+        this.imports = [];
         this.constants = [];
         this.attributes = [];
         this.operators = [];
@@ -83,9 +84,7 @@ class UmlClass {
      * Does not include any grand parent associations. That has to be done recursively.
      */
     getParentContracts() {
-        return Object.values(this.associations).filter((association) => association.realization &&
-            association.targetUmlClassStereotype !==
-                ClassStereotype.Interface);
+        return Object.values(this.associations).filter((association) => association.realization);
     }
 }
 exports.UmlClass = UmlClass;

package/lib/writerFiles.d.ts

@@ -1,4 +1,4 @@
-export declare type OutputFormats = 'svg' | 'png' | 'dot' | 'all';
+export type OutputFormats = 'svg' | 'png' | 'dot' | 'all';
 export declare const writeOutputFiles: (dot: string, fileFolderAddress: string, contractName: string, outputFormat?: OutputFormats, outputFilename?: string) => Promise<void>;
 export declare function convertDot2Svg(dot: string): any;
 export declare function writeSolidity(code: string, filename?: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sol2uml",
-  "version": "2.2.6",
+  "version": "2.3.1",
   "description": "Solidity contract visualisation tool.",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -20,25 +20,25 @@
   "license": "MIT",
   "dependencies": {
     "@aduh95/viz.js": "^3.7.0",
-    "@solidity-parser/parser": "^0.14.3",
-    "axios": "^0.27.2",
-    "axios-debug-log": "^0.8.4",
+    "@solidity-parser/parser": "^0.14.5",
+    "axios": "^1.2.1",
+    "axios-debug-log": "^1.0.0",
     "commander": "^9.4.1",
     "convert-svg-to-png": "^0.6.4",
     "debug": "^4.3.4",
-    "ethers": "^5.7.1",
+    "ethers": "^5.7.2",
     "js-graph-algorithms": "^1.0.18",
     "klaw": "^4.0.1"
   },
   "devDependencies": {
-    "@openzeppelin/contracts": "4.7.3",
-    "@types/jest": "^29.1.1",
+    "@openzeppelin/contracts": "4.8.0",
+    "@types/jest": "^29.2.4",
     "@types/klaw": "^3.0.3",
-    "jest": "^29.1.2",
-    "prettier": "^2.7.1",
+    "jest": "^29.3.1",
+    "prettier": "^2.8.1",
     "ts-jest": "^29.0.3",
     "ts-node": "^10.9.1",
-    "typescript": "^4.8.4"
+    "typescript": "^4.9.4"
   },
   "files": [
     "lib/*.js",