Merge pull request #25 from matsoftware/analyze-submodules-part1

Analyze submodules (part 1)

Author: matsoftware

requirements.txt

@@ -1,4 +1,6 @@
 matplotlib >= 2
 adjustText < 1
 pygraphviz == 1.5
-pyfunctional == 1.2
+pyfunctional == 1.2
+mergedeep == 1.3.0
+dataclasses == 0.7.0

swift_code_metrics/_analyzer.py

@@ -3,10 +3,11 @@
 
 from ._helpers import AnalyzerHelpers
 from ._parser import SwiftFileParser, SwiftFile
-from ._metrics import Framework, SyntheticData
+from ._metrics import Framework
 from ._report import ReportProcessor
 from functional import seq
 from typing import List, Optional
+from mergedeep import merge
 
 
 class Inspector:
@@ -60,8 +61,7 @@ def __analyze_directory(self, directory: str, exclude_paths: List[str], tests_de
 
     def __append_dependency(self, swift_file: 'SwiftFile'):
         framework = self.__get_or_create_framework(swift_file.framework_name)
-        framework.number_of_files += 1
-        framework.data.append_data(data=SyntheticData(swift_file=swift_file))
+        Inspector.__add_raw_files(framework=framework, swift_file=swift_file)
         # This covers the scenario where a test framework might contain no tests
         framework.is_test_framework = swift_file.is_test
 
@@ -71,6 +71,14 @@ def __append_dependency(self, swift_file: 'SwiftFile'):
                 imported_framework = Framework(f)
             framework.append_import(imported_framework)
 
+    @staticmethod
+    def __add_raw_files(framework: 'Framework', swift_file: 'SwiftFile'):
+        paths = str(swift_file.path).split('/')
+        ref_dict = swift_file
+        for key in reversed(paths):
+            ref_dict = {key: ref_dict}
+        merge(framework.raw_files, ref_dict)
+
     def __process_shared_file(self, swift_file: 'SwiftFile', directory: str):
         if not swift_file.is_shared:
             return
@@ -99,4 +107,3 @@ def __get_framework(self, name: str) -> Optional['Framework']:
             if f.name == name:
                 return f
         return None
-

swift_code_metrics/_helpers.py

@@ -1,9 +1,10 @@
 import re
 import logging
 import json
-from typing import Dict
+from typing import List,Dict
 from functional import seq
 
+
 class Log:
     __logger = logging.getLogger(__name__)
 
@@ -270,3 +271,13 @@ class JSONReader:
     def read_json_file(path: str) -> Dict:
         with open(path, 'r') as fp:
             return json.load(fp)
+
+
+# Methods
+
+def flatten_nested_dictionary_values(dictionary) -> List:
+    for v in dictionary.values():
+        if isinstance(v, dict):
+            yield from flatten_nested_dictionary_values(v)
+        else:
+            yield v

swift_code_metrics/_metrics.py

@@ -1,5 +1,6 @@
-from ._helpers import AnalyzerHelpers, Log, ParsingHelpers, ReportingHelpers
+from ._helpers import AnalyzerHelpers, Log, ParsingHelpers, ReportingHelpers, flatten_nested_dictionary_values
 from ._parser import SwiftFile
+from dataclasses import dataclass
 from functional import seq
 from typing import Dict, List, Optional
 
@@ -191,31 +192,61 @@ def __is_name_contained_in_list(framework: 'Framework', frameworks: List['Framew
                    .list()) > 0
 
 
+@dataclass
 class SyntheticData:
-    def __init__(self, swift_file: Optional['SwiftFile'] = None):
-        self.loc = 0 if swift_file is None else swift_file.loc
-        self.noc = 0 if swift_file is None else swift_file.n_of_comments
-        self.number_of_interfaces = 0 if swift_file is None else len(swift_file.interfaces)
-        self.number_of_concrete_data_structures = 0 if swift_file is None else \
-            len(swift_file.structs + swift_file.classes)
-        self.number_of_methods = 0 if swift_file is None else len(swift_file.methods)
-        self.number_of_tests = 0 if swift_file is None else len(swift_file.tests)
-
-    def append_data(self, data: 'SyntheticData'):
-        self.loc += data.loc
-        self.noc += data.noc
-        self.number_of_interfaces += data.number_of_interfaces
-        self.number_of_concrete_data_structures += data.number_of_concrete_data_structures
-        self.number_of_methods += data.number_of_methods
-        self.number_of_tests += data.number_of_tests
-
-    def remove_data(self, data: 'SyntheticData'):
-        self.loc -= data.loc
-        self.noc -= data.noc
-        self.number_of_interfaces -= data.number_of_interfaces
-        self.number_of_concrete_data_structures -= data.number_of_concrete_data_structures
-        self.number_of_methods -= data.number_of_methods
-        self.number_of_tests -= data.number_of_tests
+    """
+    Representation of synthetic code metric data
+    """
+    loc: int = 0
+    noc: int = 0
+    number_of_interfaces: int = 0
+    number_of_concrete_data_structures: int = 0
+    number_of_methods: int = 0
+    number_of_tests: int = 0
+
+    @classmethod
+    def from_swift_file(cls, swift_file: Optional['SwiftFile'] = None) -> 'SyntheticData':
+        return SyntheticData(
+            loc=0 if swift_file is None else swift_file.loc,
+            noc=0 if swift_file is None else swift_file.n_of_comments,
+            number_of_interfaces=0 if swift_file is None else len(swift_file.interfaces),
+            number_of_concrete_data_structures=0 if swift_file is None else \
+                len(swift_file.structs + swift_file.classes),
+            number_of_methods=0 if swift_file is None else len(swift_file.methods),
+            number_of_tests=0 if swift_file is None else len(swift_file.tests)
+        )
+
+    def __add__(self, data):
+        """
+        Implementation of the `+` operator
+        :param data: An instance of SyntheticData
+        :return: a new instance of SyntheticData
+        """
+        return SyntheticData(
+            loc=self.loc + data.loc,
+            noc=self.noc + data.noc,
+            number_of_interfaces=self.number_of_interfaces + data.number_of_interfaces,
+            number_of_concrete_data_structures=self.number_of_concrete_data_structures
+                                               + data.number_of_concrete_data_structures,
+            number_of_methods=self.number_of_methods + data.number_of_methods,
+            number_of_tests=self.number_of_tests + data.number_of_tests
+        )
+
+    def __sub__(self, data):
+        """
+        Implementation of the `-` operator
+        :param data: An instance of SyntheticData
+        :return: a new instance of SyntheticData
+        """
+        return SyntheticData(
+            loc=self.loc - data.loc,
+            noc=self.noc - data.noc,
+            number_of_interfaces=self.number_of_interfaces - data.number_of_interfaces,
+            number_of_concrete_data_structures=self.number_of_concrete_data_structures
+                                               - data.number_of_concrete_data_structures,
+            number_of_methods=self.number_of_methods - data.number_of_methods,
+            number_of_tests=self.number_of_tests - data.number_of_tests
+        )
 
     @property
     def poc(self) -> float:
@@ -234,30 +265,82 @@ def as_dict(self) -> Dict:
         }
 
 
+@dataclass()
 class FrameworkData(SyntheticData):
-    def __init__(self, swift_file: Optional['SwiftFile'] = None):
-        super().__init__(swift_file)
-        self.n_o_i = 0 if swift_file is None else\
-            len([imp for imp in swift_file.imports if imp not in AnalyzerHelpers.APPLE_FRAMEWORKS])
+    """
+    Enriched synthetic data
+    """
+    n_o_i: int = 0
+
+    @classmethod
+    def from_swift_file(cls, swift_file: Optional['SwiftFile'] = None) -> 'FrameworkData':
+        sd = SyntheticData.from_swift_file(swift_file=swift_file)
+        return FrameworkData.__from_sd(sd=sd,
+                                       n_o_i=0 if swift_file is None else \
+                                           len([imp for imp in swift_file.imports if imp not in \
+                                                AnalyzerHelpers.APPLE_FRAMEWORKS]))
+
+    def __add__(self, data):
+        """
+        Implementation of the `+` operator
+        :param data: An instance of FrameworkData
+        :return: a new instance of FrameworkData
+        """
+        sd = self.__current_sd().__add__(data=data)
+        return FrameworkData.__from_sd(sd=sd, n_o_i=self.n_o_i + data.n_o_i)
+
+    def __sub__(self, data):
+        """
+        Implementation of the `-` operator
+        :param data: An instance of FrameworkData
+        :return: a new instance of FrameworkData
+        """
+        sd = self.__current_sd().__sub__(data=data)
+        return FrameworkData.__from_sd(sd=sd, n_o_i=self.n_o_i - data.n_o_i)
 
     def append_framework(self, f: 'Framework'):
-        super().append_data(data=f.data)
+        sd = f.data
+        self.loc += sd.loc
+        self.noc += sd.noc
+        self.number_of_interfaces += sd.number_of_interfaces
+        self.number_of_concrete_data_structures += sd.number_of_concrete_data_structures
+        self.number_of_methods += sd.number_of_methods
+        self.number_of_tests += sd.number_of_tests
         self.n_o_i += f.number_of_imports
 
-    def remove_data(self, data: 'FrameworkData'):
-        super().remove_data(data=data)
-        self.n_o_i -= data.n_o_i
-
     @property
     def as_dict(self) -> Dict:
         return {**super().as_dict, **{"noi": self.n_o_i}}
 
+    # Private
+
+    def __current_sd(self) -> 'SyntheticData':
+        return SyntheticData(
+            loc=self.loc,
+            noc=self.noc,
+            number_of_interfaces=self.number_of_interfaces,
+            number_of_concrete_data_structures=self.number_of_concrete_data_structures,
+            number_of_methods=self.number_of_methods,
+            number_of_tests=self.number_of_tests
+        )
+
+    @classmethod
+    def __from_sd(cls, sd: 'SyntheticData', n_o_i: int) -> 'FrameworkData':
+        return FrameworkData(
+            loc=sd.loc,
+            noc=sd.noc,
+            number_of_interfaces=sd.number_of_interfaces,
+            number_of_concrete_data_structures=sd.number_of_concrete_data_structures,
+            number_of_methods=sd.number_of_methods,
+            number_of_tests=sd.number_of_tests,
+            n_o_i=n_o_i
+        )
+
 
 class Framework:
     def __init__(self, name: str, is_test_framework: bool = False):
         self.name = name
-        self.number_of_files = 0
-        self.data = SyntheticData()
+        self.raw_files = {}
         self.__total_imports = {}
         self.is_test_framework = is_test_framework
 
@@ -276,6 +359,25 @@ def append_import(self, framework_import: 'Framework'):
         else:
             self.__total_imports[framework_import] += 1
 
+    @property
+    def data(self) -> SyntheticData:
+        """
+        The metrics data describing the framework
+        :return: an instance of SyntheticData
+        """
+        if self.number_of_files == 0:
+            return SyntheticData()
+        return seq([SyntheticData.from_swift_file(swift_file=sf) for sf in self.__raw_files_data()]) \
+            .reduce(lambda sd1, sd2: sd1 + sd2)
+
+    @property
+    def number_of_files(self) -> int:
+        """
+        Number of files in the framework
+        :return: The total number of files in this framework (int)
+        """
+        return len(self.__raw_files_data())
+
     @property
     def imports(self) -> Dict[str, int]:
         """
@@ -311,12 +413,17 @@ def compact_name_description(self) -> str:
     def __filtered_imports(items: 'ItemsView') -> Dict[str, int]:
         return seq(items).filter(lambda f: f[0].name not in AnalyzerHelpers.APPLE_FRAMEWORKS).dict()
 
+    # Private
+
+    def __raw_files_data(self) -> List['SwiftFile']:
+        return list(flatten_nested_dictionary_values(self.raw_files))
+
 
+@dataclass
 class Dependency:
-    def __init__(self, name: str, dependent_framework: str, number_of_imports: int = 0):
-        self.name = name
-        self.dependent_framework = dependent_framework
-        self.number_of_imports = number_of_imports
+    name: str
+    dependent_framework: str
+    number_of_imports: int = 0
 
     def __eq__(self, other):
         return (self.name == other.name) and \
@@ -333,4 +440,3 @@ def compact_repr(self) -> str:
     @property
     def relationship(self) -> str:
         return f'{self.name} > {self.dependent_framework}'
-

swift_code_metrics/_parser.py

@@ -6,7 +6,9 @@
 
 
 class SwiftFile(object):
-    def __init__(self, framework_name: List[str],
+    def __init__(self,
+                 path: str,
+                 framework_name: str,
                  loc: int,
                  imports: List[str],
                  interfaces: List[str],
@@ -18,6 +20,7 @@ def __init__(self, framework_name: List[str],
                  is_test: bool):
         """
         Creates a SwiftFile instance that represents a parsed swift file.
+        :param path: The path of the file being analyzed
         :param framework_name: The framework where the file belongs to.
         :param loc: Lines Of Code
         :param imports: List of imported frameworks
@@ -29,6 +32,7 @@ def __init__(self, framework_name: List[str],
         :param is_shared: True if the file is shared with other frameworks
         :param is_test: True if the file is a test class
         """
+        self.path = path
         self.framework_name = framework_name
         self.loc = loc
         self.imports = imports
@@ -133,6 +137,7 @@ def parse(self) -> List['SwiftFile']:
 
         is_shared_file = len(framework_names) > 1
         return [SwiftFile(
+            path=Path(self.current_subdir.replace(f'{self.base_path}/', '')) / Path(self.file).name,
             framework_name=f,
             loc=loc,
             imports=self.attributes_regex_map[ParsingHelpers.IMPORTS],

swift_code_metrics/_report.py

@@ -13,14 +13,14 @@ def generate_report(frameworks: List['Framework'], shared_files: Dict[str, 'Swif
         # Shared files
         for _, shared_files in shared_files.items():
             shared_file = shared_files[0]
-            shared_file_data = FrameworkData(swift_file=shared_file)
+            shared_file_data = FrameworkData.from_swift_file(swift_file=shared_file)
             for _ in range((len(shared_files) - 1)):
-                report.shared_code.append_data(shared_file_data)
-                report.total_aggregate.remove_data(shared_file_data)
+                report.shared_code += shared_file_data
+                report.total_aggregate -= shared_file_data
                 if shared_file.is_test:
-                    report.test_framework_aggregate.remove_data(shared_file_data)
+                    report.test_framework_aggregate -= shared_file_data
                 else:
-                    report.non_test_framework_aggregate.remove_data(shared_file_data)
+                    report.non_test_framework_aggregate -= shared_file_data
 
         # Frameworks
         for f in sorted(frameworks, key=lambda fr: fr.name, reverse=False):

swift_code_metrics/tests/test_helper.py

@@ -164,6 +164,13 @@ def test_helpers_funcs_property_modifier_extract_substring_with_pattern_expectTr
     def test_helpers_funcs_reduce_dictionary(self):
         self.assertEqual(3, _helpers.ParsingHelpers.reduce_dictionary({"one": 1, "two": 2}))
 
+    # Additional helpers
+
+    def test_flatten_nested_dictionary_values(self):
+        nested_dictionary = {'group1': {'subGroup1': 1}, 'group2': 2, 'group3': {'subGroup3': {'subSubGroup3': 3}}}
+        flattened_values = list(_helpers.flatten_nested_dictionary_values(nested_dictionary))
+        self.assertEqual([1, 2, 3], flattened_values)
+
 
 if __name__ == '__main__':
     unittest.main()