draft implementation of methods support.

jonykalavera · jonykalavera · commit 823a7ca26c85 · 2022-04-15T22:02:43.000+02:00
diff --git a/py2puml/domain/umlclass.py b/py2puml/domain/umlclass.py
@@ -1,5 +1,6 @@
+from inspect import signature
 from typing import List
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from py2puml.domain.umlitem import UmlItem
 
@@ -9,7 +10,15 @@ class UmlAttribute(object):
     type: str
     static: bool
 
+
+@dataclass
+class UmlMethod(object):
+    name: str
+    signature: str
+
+
 @dataclass
 class UmlClass(UmlItem):
     attributes: List[UmlAttribute]
+    methods: List[UmlMethod]
     is_abstract: bool = False
diff --git a/py2puml/exportpuml.py b/py2puml/exportpuml.py
@@ -1,3 +1,4 @@
+from inspect import signature
 from typing import List, Iterable
 
 from py2puml.domain.umlitem import UmlItem
@@ -9,6 +10,7 @@
 PUML_FILE_END = '@enduml\n'
 PUML_ITEM_START_TPL = '{item_type} {item_fqn} {{\n'
 PUML_ATTR_TPL = '  {attr_name}: {attr_type}{staticity}\n'
+PUML_METHOD_TPL = '  {name}{signature}\n'
 PUML_ITEM_END = '}\n'
 PUML_COMPOSITION_TPL = '{source_fqn} {rel_type}-- {target_fqn}\n'
 
@@ -31,6 +33,8 @@ def to_puml_content(uml_items: List[UmlItem], uml_relations: List[UmlRelation])
             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)
+            for uml_method in uml_class.methods:
+                yield PUML_METHOD_TPL.format(name=uml_method.name, signature=uml_method.signature)
             yield PUML_ITEM_END
         else:
             raise TypeError(f'cannot process uml_item of type {uml_item.__class__}')
diff --git a/py2puml/inspection/inspectclass.py b/py2puml/inspection/inspectclass.py
@@ -1,15 +1,15 @@
 
-from inspect import isabstract
+from inspect import isabstract, signature
+import inspect
 from typing import Type, List, Dict
 
 from re import compile
 from dataclasses import dataclass
 
 from py2puml.domain.umlitem import UmlItem
-from py2puml.domain.umlclass import UmlClass, UmlAttribute
+from py2puml.domain.umlclass import UmlClass, UmlAttribute, UmlMethod
 from py2puml.domain.umlrelation import UmlRelation, RelType
 from py2puml.parsing.parseclassconstructor import parse_class_constructor
-from py2puml.utils import inspect_domain_definition
 
 CONCRETE_TYPE_PATTERN = compile("^<(?:class|enum) '([\\.|\\w]+)'>$")
 
@@ -33,20 +33,12 @@ def handle_inheritance_relation(
             )
 
 def inspect_static_attributes(
-    class_type: Type,
     class_type_fqn: str,
+    definition_attrs: List[UmlAttribute],
+    class_type: Type,
     root_module_name: str,
-    domain_items_by_fqn: Dict[str, UmlItem],
     domain_relations: List[UmlRelation]
 ) -> List[UmlAttribute]:
-    definition_attrs: List[UmlAttribute] = []
-    uml_class = UmlClass(
-        name=class_type.__name__,
-        fqn=class_type_fqn,
-        attributes=definition_attrs,
-        is_abstract=isabstract(class_type)
-    )
-    domain_items_by_fqn[class_type_fqn] = uml_class
     # inspect_domain_definition(class_type)
     type_annotations = getattr(class_type, '__annotations__', None)
     if type_annotations is not None:
@@ -58,7 +50,7 @@ def inspect_static_attributes(
                 if attr_class.__module__.startswith(root_module_name):
                     attr_type = attr_class.__name__
                     domain_relations.append(
-                        UmlRelation(uml_class.fqn, f'{attr_class.__module__}.{attr_class.__name__}', RelType.COMPOSITION)
+                        UmlRelation(class_type_fqn, f'{attr_class.__module__}.{attr_class.__name__}', RelType.COMPOSITION)
                     )
                 else:
                     attr_type = concrete_type
@@ -73,7 +65,7 @@ def inspect_static_attributes(
                         if getattr(component_class, '__name__', None) is not None
                     ]
                     domain_relations.extend([
-                        UmlRelation(uml_class.fqn, f'{component_class.__module__}.{component_class.__name__}', RelType.COMPOSITION)
+                        UmlRelation(class_type_fqn, f'{component_class.__module__}.{component_class.__name__}', RelType.COMPOSITION)
                         for component_class in component_classes
                         if component_class.__module__.startswith(root_module_name)
                     ])
@@ -85,16 +77,50 @@ def inspect_static_attributes(
 
     return definition_attrs
 
+def inspect_methods(
+    definition_methods, class_type,
+):
+    no_dunder = lambda x: not (x[0].startswith('__') or x[0].endswith('__'))
+    methods = filter(no_dunder, inspect.getmembers(class_type, callable))
+    for name, method in methods:
+        signature = inspect.signature(method)
+        uml_method = UmlMethod(
+            name=name,
+            signature=str(signature),
+        )
+        definition_methods.append(uml_method)
+
+
+def handle_class_type(
+    class_type: Type,
+    class_type_fqn: str,
+    domain_items_by_fqn: Dict[str, UmlItem],
+) -> UmlClass:
+    definition_attrs: List[UmlAttribute] = []
+    definition_methods: List[UmlMethod] = []
+    uml_class = UmlClass(
+        name=class_type.__name__,
+        fqn=class_type_fqn,
+        attributes=definition_attrs,
+        methods=definition_methods,
+        is_abstract=isabstract(class_type)
+    )
+    domain_items_by_fqn[class_type_fqn] = uml_class
+    return uml_class
+
 def inspect_class_type(
     class_type: Type,
     class_type_fqn: str,
     root_module_name: str,
     domain_items_by_fqn: Dict[str, UmlItem],
     domain_relations: List[UmlRelation]
 ):
+    uml_class = handle_class_type(class_type, class_type_fqn, domain_items_by_fqn)
     attributes = inspect_static_attributes(
-        class_type, class_type_fqn, root_module_name,
-        domain_items_by_fqn, domain_relations
+        class_type_fqn, uml_class.attributes, class_type, root_module_name, domain_relations
+    )
+    inspect_methods(
+        uml_class.methods, class_type
     )
     instance_attributes, compositions = parse_class_constructor(class_type, class_type_fqn, root_module_name)
     attributes.extend(instance_attributes)
@@ -103,19 +129,20 @@ def inspect_class_type(
     handle_inheritance_relation(class_type, class_type_fqn, root_module_name, domain_relations)
 
 def inspect_dataclass_type(
-    class_type: Type[dataclass],
+    class_type: Type,
     class_type_fqn: str,
     root_module_name: str,
     domain_items_by_fqn: Dict[str, UmlItem],
     domain_relations: List[UmlRelation]
 ):
-    for attribute in inspect_static_attributes(
-        class_type,
-        class_type_fqn,
-        root_module_name,
-        domain_items_by_fqn,
-        domain_relations
-    ):
+    uml_class = handle_class_type(class_type, class_type_fqn, domain_items_by_fqn)
+    attributes = inspect_static_attributes(
+        class_type_fqn, uml_class.attributes, class_type, root_module_name, domain_relations
+    )
+    inspect_methods(
+        uml_class.methods, class_type
+    )
+    for attribute in attributes:
         attribute.static = False
 
     handle_inheritance_relation(class_type, class_type_fqn, root_module_name, domain_relations)
diff --git a/py2puml/inspection/inspectnamedtuple.py b/py2puml/inspection/inspectnamedtuple.py
@@ -16,5 +16,6 @@ def inspect_namedtuple_type(
         attributes=[
             UmlAttribute(tuple_field, 'Any', False)
             for tuple_field in namedtuple_type._fields
-        ]
+        ],
+        methods=[],
     )
diff --git a/py2puml/py2puml.domain.puml b/py2puml/py2puml.domain.puml
@@ -6,12 +6,17 @@ class py2puml.domain.umlclass.UmlAttribute {
 }
 class py2puml.domain.umlclass.UmlClass {
   attributes: List[UmlAttribute]
+  methods: List[UmlMethod]
   is_abstract: bool
 }
 class py2puml.domain.umlitem.UmlItem {
   name: str
   fqn: str
 }
+class py2puml.domain.umlclass.UmlMethod {
+  name: str
+  signature: str
+}
 class py2puml.domain.umlenum.Member {
   name: str
   value: str
@@ -29,6 +34,7 @@ class py2puml.domain.umlrelation.UmlRelation {
   type: RelType
 }
 py2puml.domain.umlclass.UmlClass *-- py2puml.domain.umlclass.UmlAttribute
+py2puml.domain.umlclass.UmlClass *-- py2puml.domain.umlclass.UmlMethod
 py2puml.domain.umlitem.UmlItem <|-- py2puml.domain.umlclass.UmlClass
 py2puml.domain.umlenum.UmlEnum *-- py2puml.domain.umlenum.Member
 py2puml.domain.umlitem.UmlItem <|-- py2puml.domain.umlenum.UmlEnum

Original file line number	Diff line number	Diff line change
`@@ -16,5 +16,6 @@ def inspect_namedtuple_type(`
`16`	`16`	`attributes=[`
`17`	`17`	`UmlAttribute(tuple_field, 'Any', False)`
`18`	`18`	`for tuple_field in namedtuple_type._fields`
`19`		`- ]`
	`19`	`+ ],`
	`20`	`+ methods=[],`
`20`	`21`	`)`