Add methods

init.sh

@@ -21,4 +21,4 @@ echo "$(date '+%Y-%m-%d_%H:%M:%S') $(poetry --version) will be used to install d
 
 # installs the project dependencies
 echo "$(date '+%Y-%m-%d_%H:%M:%S') poetry ${depsinstall}"
-poetry ${depsinstall}
+poetry ${depsinstall}

py2puml/asserts.py

@@ -10,6 +10,7 @@ def assert_py2puml_is_file_content(domain_path: str, domain_module: str, diagram
     with open(diagram_filepath, 'r', encoding='utf8') as expected_puml_file:
         assert_py2puml_is_stringio(domain_path, domain_module, expected_puml_file)
 
+
 def assert_py2puml_is_stringio(domain_path: str, domain_module: str, expected_content_stream: StringIO):
     # generates the PlantUML documentation
     puml_content = list(py2puml(domain_path, domain_module))
@@ -20,6 +21,9 @@ def assert_py2puml_is_stringio(domain_path: str, domain_module: str, expected_co
 def assert_multilines(actual_multilines: List[str], expected_multilines: Iterable[str]):
     line_index = 0
     for line_index, (actual_line, expected_line) in enumerate(zip(actual_multilines, expected_multilines)):
-        assert actual_line == expected_line, f'actual and expected contents have changed at line {line_index + 1}: {actual_line=}, {expected_line=}'
-
-    assert line_index + 1 == len(actual_multilines), f'actual and expected diagrams have {line_index + 1} lines'
+        # print(actual_line[:-1])
+        assert (
+            actual_line == expected_line
+        ), f'actual and expected contents have changed at line {line_index + 1}: {actual_line=}, {expected_line=}'
+
+    assert line_index + 1 == len(actual_multilines), f'actual and expected diagrams have {line_index + 1} lines'

py2puml/cli.py

@@ -18,7 +18,13 @@ def run():
 
     argparser.add_argument('-v', '--version', action='version', version='py2puml 0.7.2')
     argparser.add_argument('path', metavar='path', type=str, help='the filepath to the domain')
-    argparser.add_argument('module', metavar='module', type=str, help='the module name of the domain', default=None)
+    argparser.add_argument(
+        'module',
+        metavar='module',
+        type=str,
+        help='the module name of the domain',
+        default=None,
+    )
 
     args = argparser.parse_args()
     print(''.join(py2puml(args.path, args.module)))

py2puml/domain/package.py

@@ -1,9 +1,11 @@
 from dataclasses import dataclass, field
 from typing import List
 
+
 @dataclass
 class Package:
-    '''A folder or a python module'''
+    """A folder or a python module"""
+
     name: str
     children: List['Package'] = field(default_factory=list)
     items_number: int = 0

py2puml/domain/umlclass.py

@@ -1,15 +1,47 @@
-from typing import List
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from typing import Dict, List
 
 from py2puml.domain.umlitem import UmlItem
 
+
 @dataclass
 class UmlAttribute:
     name: str
     type: str
     static: bool
 
+
+@dataclass
+class UmlMethod:
+    name: str
+    arguments: Dict = field(default_factory=dict)
+    is_static: bool = False
+    is_class: bool = False
+    return_type: str = None
+
+    def represent_as_puml(self):
+        items = []
+        if self.is_static:
+            items.append('{static}')
+        if self.return_type:
+            items.append(self.return_type)
+        items.append(f'{self.name}({self.signature})')
+        return ' '.join(items)
+
+    @property
+    def signature(self):
+        if self.arguments:
+            return ', '.join(
+                [
+                    f'{arg_type} {arg_name}' if arg_type else f'{arg_name}'
+                    for arg_name, arg_type in self.arguments.items()
+                ]
+            )
+        return ''
+
+
 @dataclass
 class UmlClass(UmlItem):
     attributes: List[UmlAttribute]
+    methods: List[UmlMethod]
     is_abstract: bool = False

py2puml/domain/umlenum.py

@@ -1,13 +1,15 @@
-from typing import List
 from dataclasses import dataclass
+from typing import List
 
 from py2puml.domain.umlitem import UmlItem
 
+
 @dataclass
 class Member:
     name: str
     value: str
 
+
 @dataclass
 class UmlEnum(UmlItem):
     members: List[Member]

py2puml/domain/umlitem.py

@@ -1,6 +1,7 @@
 from dataclasses import dataclass
 
+
 @dataclass
 class UmlItem:
     name: str
-    fqn: str
+    fqn: str

py2puml/domain/umlrelation.py

@@ -1,11 +1,13 @@
 from dataclasses import dataclass
 from enum import Enum, unique
 
+
 @unique
 class RelType(Enum):
     COMPOSITION = '*'
     INHERITANCE = '<|'
 
+
 @dataclass
 class UmlRelation:
     source_fqn: str

py2puml/example.py

@@ -2,9 +2,7 @@
 
 if __name__ == '__main__':
     # outputs the PlantUML content in the terminal
-    print(''.join(
-        py2puml('py2puml/domain', 'py2puml.domain')
-    ))
+    print(''.join(py2puml('py2puml/domain', 'py2puml.domain')))
 
     # writes the PlantUML content in a file
     with open('py2puml/py2puml.domain.puml', 'w', encoding='utf8') as puml_file:

py2puml/export/namespace.py

@@ -3,31 +3,31 @@
 from py2puml.domain.package import Package
 from py2puml.domain.umlitem import UmlItem
 
-
 # templating constants
 INDENT = '  '
 PUML_NAMESPACE_START_TPL = '{indentation}namespace {namespace_name} {{'
 PUML_NAMESPACE_END_TPL = '{indentation}}}\n'
 
 
 def get_or_create_module_package(root_package: Package, domain_parts: List[str]) -> Package:
-    '''Returns or create the package containing the tail domain part'''
+    """Returns or create the package containing the tail domain part"""
     package = root_package
     for domain_part in domain_parts:
-        domain_package = next((
-            sub_package for sub_package in package.children
-            if sub_package.name == domain_part
-        ), None)
+        domain_package = next(
+            (sub_package for sub_package in package.children if sub_package.name == domain_part),
+            None,
+        )
         if domain_package is None:
             domain_package = Package(domain_part)
             package.children.append(domain_package)
         package = domain_package
     return package
 
+
 def visit_package(package: Package, parent_namespace_names: Tuple[str], indentation_level: int) -> Iterable[str]:
-    '''
+    """
     Recursively visits the package and its subpackages to produce the PlantUML documentation about the namespace
-    '''
+    """
     package_with_items = package.items_number > 0
     # prints the namespace if:
     # - it has inner uml_items
@@ -49,7 +49,7 @@ def visit_package(package: Package, parent_namespace_names: Tuple[str], indentat
         # initializes the namespace decalaration but not yield yet: we don't know if it should be closed now or if there is inner content
         start_of_namespace_line = PUML_NAMESPACE_START_TPL.format(
             indentation=INDENT * indentation_level,
-            namespace_name='.'.join(namespace_names)
+            namespace_name='.'.join(namespace_names),
         )
 
     parent_names = () if print_namespace else namespace_names
@@ -72,21 +72,23 @@ def visit_package(package: Package, parent_namespace_names: Tuple[str], indentat
         else:
             yield PUML_NAMESPACE_END_TPL.format(indentation=start_of_namespace_line)
 
+
 def build_packages_structure(uml_items: List[UmlItem]) -> Package:
-    '''
+    """
     Creates the Package arborescent structure with the given UML items with their fully-qualified module names
-    '''
+    """
     root_package = Package(None)
     for uml_item in uml_items:
         module_package = get_or_create_module_package(root_package, uml_item.fqn.split('.')[:-1])
         module_package.items_number += 1
 
     return root_package
 
+
 def puml_namespace_content(uml_items: List[UmlItem]) -> Iterable[str]:
-    '''
+    """
     Yields the documentation about the packages structure in the PlantUML syntax
-    '''
+    """
     root_package = Package(None)
     # creates the Package arborescent structure with the given UML items with their fully-qualified module names
     for uml_item in uml_items:
@@ -95,4 +97,4 @@ def puml_namespace_content(uml_items: List[UmlItem]) -> Iterable[str]:
 
     # yields the documentation using a visitor pattern approach
     for namespace_line in visit_package(root_package, (), 0):
-        yield f"{namespace_line}"
+        yield f'{namespace_line}'

py2puml/export/puml.py

@@ -1,8 +1,8 @@
-from typing import List, Iterable
+from typing import Iterable, List
 
-from py2puml.domain.umlitem import UmlItem
 from py2puml.domain.umlclass import UmlClass
 from py2puml.domain.umlenum import UmlEnum
+from py2puml.domain.umlitem import UmlItem
 from py2puml.domain.umlrelation import UmlRelation
 from py2puml.export.namespace import puml_namespace_content
 
@@ -17,6 +17,7 @@
 FEATURE_STATIC = ' {static}'
 FEATURE_INSTANCE = ''
 
+
 def to_puml_content(diagram_name: str, uml_items: List[UmlItem], uml_relations: List[UmlRelation]) -> Iterable[str]:
     yield PUML_FILE_START.format(diagram_name=diagram_name)
 
@@ -30,13 +31,26 @@ def to_puml_content(diagram_name: str, uml_items: List[UmlItem], uml_relations:
             uml_enum: UmlEnum = uml_item
             yield PUML_ITEM_START_TPL.format(item_type='enum', item_fqn=uml_enum.fqn)
             for member in uml_enum.members:
-                yield PUML_ATTR_TPL.format(attr_name=member.name, attr_type=member.value, staticity=FEATURE_STATIC)
+                yield PUML_ATTR_TPL.format(
+                    attr_name=member.name,
+                    attr_type=member.value,
+                    staticity=FEATURE_STATIC,
+                )
             yield PUML_ITEM_END
         elif isinstance(uml_item, UmlClass):
             uml_class: UmlClass = uml_item
-            yield PUML_ITEM_START_TPL.format(item_type='abstract class' if uml_item.is_abstract else 'class', item_fqn=uml_class.fqn)
+            yield PUML_ITEM_START_TPL.format(
+                item_type='abstract class' if uml_item.is_abstract else 'class',
+                item_fqn=uml_class.fqn,
+            )
             for uml_attr in uml_class.attributes:
-                yield PUML_ATTR_TPL.format(attr_name=uml_attr.name, attr_type=uml_attr.type, staticity=FEATURE_STATIC if uml_attr.static else FEATURE_INSTANCE)
+                yield PUML_ATTR_TPL.format(
+                    attr_name=uml_attr.name,
+                    attr_type=uml_attr.type,
+                    staticity=FEATURE_STATIC if uml_attr.static else FEATURE_INSTANCE,
+                )
+            for uml_method in uml_class.methods:
+                yield f'  {uml_method.represent_as_puml()}\n'
             yield PUML_ITEM_END
         else:
             raise TypeError(f'cannot process uml_item of type {uml_item.__class__}')
@@ -46,7 +60,7 @@ def to_puml_content(diagram_name: str, uml_items: List[UmlItem], uml_relations:
         yield PUML_RELATION_TPL.format(
             source_fqn=uml_relation.source_fqn,
             rel_type=uml_relation.type.value,
-            target_fqn=uml_relation.target_fqn
+            target_fqn=uml_relation.target_fqn,
         )
 
     yield PUML_FILE_FOOTER