metripy 0.2.8__py3-none-any.whl → 0.3.1__py3-none-any.whl

metripy/Metric/Trend/FileTrendMetric.py

@@ -0,0 +1,46 @@
+class FileTrendMetric:
+    def __init__(
+        self,
+        historical_loc: int,
+        loc: int,
+        historical_totalCc: int,
+        totalCc: int,
+        historical_avgCcPerFunction: float,
+        avgCcPerFunction: float,
+        historical_maintainabilityIndex: float,
+        maintainabilityIndex: float,
+        historical_avgLocPerFunction: float,
+        avgLocPerFunction: float,
+    ):
+        self.historical_loc = historical_loc
+        self.loc_delta = loc - historical_loc
+
+        self.historical_totalCc = historical_totalCc
+        self.totalCc_delta = totalCc - historical_totalCc
+
+        self.historical_avgCcPerFunction = historical_avgCcPerFunction
+        self.avgCcPerFunction_delta = avgCcPerFunction - historical_avgCcPerFunction
+
+        self.maintainabilityIndex_delta = (
+            maintainabilityIndex - historical_maintainabilityIndex
+        )
+        self.historical_maintainabilityIndex = historical_maintainabilityIndex
+
+        self.avgLocPerFunction_delta = avgLocPerFunction - historical_avgLocPerFunction
+        self.historical_avgLocPerFunction = historical_avgLocPerFunction
+
+    def to_dict(self) -> dict:
+        return {
+            "historical_loc": round(self.historical_loc, 2),
+            "loc_delta": round(self.loc_delta, 2),
+            "historical_totalCc": round(self.historical_totalCc, 2),
+            "totalCc_delta": round(self.totalCc_delta, 2),
+            "historical_avgCcPerFunction": round(self.historical_avgCcPerFunction, 2),
+            "avgCcPerFunction_delta": round(self.avgCcPerFunction_delta, 2),
+            "historical_maintainabilityIndex": round(
+                self.historical_maintainabilityIndex, 2
+            ),
+            "maintainabilityIndex_delta": round(self.maintainabilityIndex_delta, 2),
+            "historical_avgLocPerFunction": round(self.historical_avgLocPerFunction, 2),
+            "avgLocPerFunction_delta": round(self.avgLocPerFunction_delta, 2),
+        }

metripy/Metric/Trend/FunctionTrendMetric.py

@@ -0,0 +1,28 @@
+class FunctionTrendMetric:
+    def __init__(
+        self,
+        historical_loc: int,
+        loc: int,
+        historical_complexity: int,
+        complexity: int,
+        historical_maintainability_index: float,
+        maintainability_index: float,
+    ):
+        self.historical_loc = historical_loc
+        self.loc_delta = loc - historical_loc
+        self.historical_complexity = historical_complexity
+        self.complexity_delta = complexity - historical_complexity
+        self.historical_maintainability_index = historical_maintainability_index
+        self.maintainability_index_delta = (
+            maintainability_index - historical_maintainability_index
+        )
+
+    def to_dict(self) -> dict:
+        return {
+            "historical_loc": self.historical_loc,
+            "loc_delta": self.loc_delta,
+            "historical_complexity": self.historical_complexity,
+            "complexity_delta": self.complexity_delta,
+            "historical_maintainability_index": self.historical_maintainability_index,
+            "maintainability_index_delta": self.maintainability_index_delta,
+        }

metripy/Metric/Trend/SegmentedTrendMetric.py

@@ -0,0 +1,29 @@
+from metripy.Metric.Code.SegmentedMetrics import SegmentedMetrics
+
+
+class SegmentedTrendMetric:
+    def __init__(
+        self,
+        historical_segmentation: SegmentedMetrics,
+        segmentation: SegmentedMetrics,
+    ):
+        self.historical_good = historical_segmentation.good
+        self.good_delta = segmentation.good - historical_segmentation.good
+        self.historical_ok = historical_segmentation.ok
+        self.ok_delta = segmentation.ok - historical_segmentation.ok
+        self.historical_warning = historical_segmentation.warning
+        self.warning_delta = segmentation.warning - historical_segmentation.warning
+        self.historical_critical = historical_segmentation.critical
+        self.critical_delta = segmentation.critical - historical_segmentation.critical
+
+    def to_dict(self) -> dict:
+        return {
+            "historical_good": self.historical_good,
+            "good_delta": self.good_delta,
+            "historical_ok": self.historical_ok,
+            "ok_delta": self.ok_delta,
+            "historical_warning": self.historical_warning,
+            "warning_delta": self.warning_delta,
+            "historical_critical": self.historical_critical,
+            "critical_delta": self.critical_delta,
+        }

metripy/Report/Html/DependencyPageRenderer.py

@@ -0,0 +1,21 @@
+from metripy.Dependency.Dependency import Dependency
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class DependencyPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        dependencies = metrics.dependencies if metrics.dependencies is not None else []
+        license_by_type = Dependency.get_lisence_distribution(dependencies)
+
+        self.render_template(
+            "dependencies.html",
+            {
+                "has_dependencies_data": bool(metrics.dependencies),
+                "dependencies": [d.to_dict() for d in dependencies],
+                "license_distribution": license_by_type,
+            },
+        )

metripy/Report/Html/FilesPageRenderer.py

@@ -0,0 +1,28 @@
+import json
+
+from metripy.Metric.FileTree.FileTreeParser import FileTreeParser
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class FilesPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        file_names = []
+        file_details = {}
+        for file_metrics in metrics.file_metrics:
+            file_name = file_metrics.full_name
+            file_details[file_name] = file_metrics.to_dict()
+            file_names.append(file_name)
+
+        filetree = FileTreeParser.parse(file_names, shorten=True)
+
+        self.render_template(
+            "files.html",
+            {
+                "filetree": json.dumps(filetree.to_dict()),
+                "file_details": json.dumps(file_details),
+            },
+        )

metripy/Report/Html/GitAnalysisPageRenderer.py

@@ -0,0 +1,55 @@
+import json
+
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class GitAnalysisPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def _render_empty_template(self):
+        self.render_template(
+            "git_analysis.html",
+            {
+                "has_git_analysis_data": False,
+                "git_analysis": {},
+                "git_analysis_json": "{}",
+                "git_stats_data": "{}",
+                "git_churn_data": "{}",
+                "git_silos_data": [],
+                "git_contributors": [],
+                "git_hotspots_data": [],
+            },
+        )
+
+    def render(self, metrics: ProjectMetrics):
+        if not metrics.git_metrics:
+            self._render_empty_template()
+            return
+
+        self.render_template(
+            "git_analysis.html",
+            {
+                "has_git_analysis_data": bool(metrics.git_metrics),
+                "git_analysis": metrics.git_metrics.to_dict(),
+                "git_analysis_json": json.dumps(
+                    metrics.git_metrics.get_contributors_dict(), indent=4
+                ),
+                "git_stats_data": json.dumps(
+                    metrics.git_metrics.get_commit_stats_per_month(), indent=4
+                ),  # git commit graph
+                "git_churn_data": json.dumps(
+                    metrics.git_metrics.get_churn_per_month(), indent=4
+                ),  # git chrun graph
+                "git_silos_data": metrics.git_metrics.get_silos_list()[
+                    :10
+                ],  # silos list
+                "git_contributors": metrics.git_metrics.get_contributors_list()[
+                    :10
+                ],  # contributors list
+                "git_hotspots_data": metrics.git_metrics.get_hotspots_list()[
+                    :10
+                ],  # hotspots list
+            },
+        )

metripy/Report/Html/IndexPageRenderer.py

@@ -0,0 +1,40 @@
+import json
+
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class IndexPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        git_stats_data = {}
+        if metrics.git_metrics:
+            git_stats_data = metrics.git_metrics.get_commit_stats_per_month()
+
+        self.render_template(
+            "index.html",
+            {
+                "git_stats_data": json.dumps(git_stats_data, indent=4),
+                "total_code_metrics": metrics.total_code_metrics.to_dict(),
+                "has_total_code_metrics_trend": metrics.total_code_metrics.trend
+                is not None,
+                "total_code_metrics_trend": (
+                    metrics.total_code_metrics.trend.to_dict()
+                    if metrics.total_code_metrics.trend
+                    else None
+                ),
+                "segmentation_data": json.dumps(
+                    metrics.total_code_metrics.to_dict_segmentation(), indent=4
+                ),
+                "segmentation_data_trend": (
+                    json.dumps(
+                        metrics.total_code_metrics.trend.to_dict_segmentation(),
+                        indent=4,
+                    )
+                    if metrics.total_code_metrics.trend
+                    else None
+                ),
+            },
+        )

metripy/Report/Html/PageRenderer.py

@@ -0,0 +1,43 @@
+import os
+from datetime import datetime
+
+from py_template_engine import TemplateEngine
+
+from metripy.Application.Info import Info
+
+
+class PageRenderer:
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        self.template_dir = template_dir
+        self.output_dir = output_dir
+
+        self.global_template_args = {
+            "project_name": project_name,
+            "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+            "author": "Metripy",
+            "version": Info().get_version(),
+        }
+
+    @staticmethod
+    def _stringify_values(obj):
+        if isinstance(obj, dict):
+            return {
+                key: PageRenderer._stringify_values(value) for key, value in obj.items()
+            }
+        elif isinstance(obj, list):
+            return [PageRenderer._stringify_values(item) for item in obj]
+        else:
+            return str(obj)
+
+    def render_template(self, template_name: str, data: dict):
+        data = self._stringify_values(
+            {
+                **self.global_template_args,
+                **data,
+            }
+        )
+        engine = TemplateEngine(os.path.join(self.template_dir, template_name))
+        content = engine.render(**data)
+        with open(os.path.join(self.output_dir, template_name), "w") as file:
+            file.write(content)

metripy/Report/Html/PageRendererFactory.py

@@ -0,0 +1,37 @@
+from metripy.Report.Html.DependencyPageRenderer import DependencyPageRenderer
+from metripy.Report.Html.FilesPageRenderer import FilesPageRenderer
+from metripy.Report.Html.GitAnalysisPageRenderer import GitAnalysisPageRenderer
+from metripy.Report.Html.IndexPageRenderer import IndexPageRenderer
+from metripy.Report.Html.TopOffendersPageRenderer import TopOffendersPageRenderer
+from metripy.Report.Html.TrendsPageRenderer import TrendsPageRenderer
+
+
+class PageRendererFactory:
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        self.template_dir = template_dir
+        self.output_dir = output_dir
+        self.project_name = project_name
+
+    def create_index_page_renderer(self) -> IndexPageRenderer:
+        return IndexPageRenderer(self.template_dir, self.output_dir, self.project_name)
+
+    def create_files_page_renderer(self) -> FilesPageRenderer:
+        return FilesPageRenderer(self.template_dir, self.output_dir, self.project_name)
+
+    def create_top_offenders_page_renderer(self) -> TopOffendersPageRenderer:
+        return TopOffendersPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_git_analysis_page_renderer(self) -> GitAnalysisPageRenderer:
+        return GitAnalysisPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_dependency_page_renderer(self) -> DependencyPageRenderer:
+        return DependencyPageRenderer(
+            self.template_dir, self.output_dir, self.project_name
+        )
+
+    def create_trends_page_renderer(self) -> TrendsPageRenderer:
+        return TrendsPageRenderer(self.template_dir, self.output_dir, self.project_name)

metripy/Report/Html/Reporter.py

@@ -1,16 +1,13 @@
-import json
 import os
 import shutil
 from datetime import datetime
 
-from py_template_engine import TemplateEngine
 
 from metripy.Application.Config.ReportConfig import ReportConfig
 from metripy.Component.Output.CliOutput import CliOutput
-from metripy.Metric.FileTree.FileTreeParser import FileTreeParser
 from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRendererFactory import PageRendererFactory
 from metripy.Report.ReporterInterface import ReporterInterface
-from metripy.Dependency.Dependency import Dependency
 
 
 class Reporter(ReporterInterface):
@@ -20,6 +17,11 @@ class Reporter(ReporterInterface):
         self.config: ReportConfig = config
         self.output = output
         self.template_dir = os.path.join(os.getcwd(), "templates/html_report")
+        self.project_name = project_name
+
+        self.page_renderer_factory = PageRendererFactory(
+            self.template_dir, self.config.path, self.project_name
+        )
 
         self.global_template_args = {
             "project_name": project_name,
@@ -54,152 +56,69 @@ class Reporter(ReporterInterface):
             os.path.join(self.config.path, "css"),
             dirs_exist_ok=True,
         )
-        # shutil.copytree(os.path.join(self.template_dir, "images"), os.path.join(self.config.path, "images"), dirs_exist_ok=True)
+        shutil.copytree(
+            os.path.join(self.template_dir, "images"),
+            os.path.join(self.config.path, "images"),
+            dirs_exist_ok=True,
+        )
         # shutil.copytree(os.path.join(self.template_dir, "fonts"), os.path.join(self.config.path, "fonts"), dirs_exist_ok=True)
 
-        # render templates
-        git_stats_data = {}
-        if metrics.git_metrics:
-            git_stats_data = metrics.git_metrics.get_commit_stats_per_month()
-
-        self.output.writeln("<info>Rendering index page</info>")
-        # Render main index page
-        self.render_template(
-            "index.html",
-            {
-                "git_stats_data": json.dumps(git_stats_data, indent=4),
-                "total_code_metrics": metrics.total_code_metrics.to_dict(),
-                "segmentation_data": json.dumps(
-                    metrics.total_code_metrics.to_dict_segmentation(), indent=4
-                ),
-                "project_name": "Metripy",
-                "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "author": "Metripy",
-                "version": "1.0.0",
-            },
+        # copy logo, lies 2 down from the templates directory
+        shutil.copy(
+            os.path.join(self.template_dir, "../..", "logo.svg"),
+            os.path.join(self.config.path, "images", "logo.svg"),
         )
-        self.output.writeln("<success>Done rendering index page</success>")
 
-        # Render files page
+        # Render main pages
+        self.render_index_page(metrics)
         self.render_files_page(metrics)
-        # Render git analysis page
+        self.render_top_offenders_page(metrics)
         self.render_git_analysis_page(metrics)
-
         self.render_dependencies_page(metrics)
+        self.render_trends_page(metrics)
 
         self.output.writeln(
             f"<success>HTML report generated in {self.config.path} directory</success>"
         )
-
-    def render_template(self, template_name: str, data: dict) -> str:
-        engine = TemplateEngine(os.path.join(self.template_dir, template_name))
-        content = engine.render(**data)
-        with open(os.path.join(self.config.path, template_name), "w") as file:
-            file.write(content)
-
-    def render_dependencies_page(self, metrics: ProjectMetrics):
-        """Render the dependencies page with dependency details and stats"""
-        if not metrics.dependencies:
-            self.output.writeln("<success>No dependencies to render</success>")
-            return
-
-        self.output.writeln("<info>Rendering dependencies page</info>")
-
-        dependencies = metrics.dependencies if metrics.dependencies is not None else []
-
-        # TODO render a pie chart
-        license_by_type = Dependency.get_lisence_distribution(dependencies)
-
-        print(json.dumps(license_by_type, indent=2))
-
-        self.render_template(
-            "dependencies.html",
-            {
-                "dependencies": [d.to_dict() for d in dependencies],
-                "project_name": "Metripy",
-                "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            },
-        )
         self.output.writeln(
-            "<success>Dependencies page generated successfully</success>"
+            f"<success>Open HTML report: {self.config.path}/index.html</success>"
         )
 
+    def render_index_page(self, metrics: ProjectMetrics):
+        self.output.writeln("<info>Rendering index page</info>")
+        self.page_renderer_factory.create_index_page_renderer().render(metrics)
+        self.output.writeln("<success>Done rendering index page</success>")
+
     def render_files_page(self, metrics: ProjectMetrics):
         """Render the files page with file details and analysis"""
         self.output.writeln("<info>Rendering files page</info>")
+        self.page_renderer_factory.create_files_page_renderer().render(metrics)
+        self.output.writeln("<success>Files page generated successfully</success>")
 
-        file_names = []
-        file_details = {}
-        for file_metrics in metrics.file_metrics:
-            file_name = file_metrics.full_name
-            file_details[file_name] = file_metrics.to_dict()
-            file_names.append(file_name)
-
-        filetree = FileTreeParser.parse(file_names, shorten=True)
-
-        self.render_template(
-            "files.html",
-            {
-                "filetree": json.dumps(filetree.to_dict()),
-                "file_details": json.dumps(file_details),
-                "project_name": "Metripy",
-                "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-            },
+    def render_top_offenders_page(self, metrics: ProjectMetrics):
+        self.output.writeln("<info>Rendering top offenders page</info>")
+        self.page_renderer_factory.create_top_offenders_page_renderer().render(metrics)
+        self.output.writeln(
+            "<success>Top offenders page generated successfully</success>"
         )
-        self.output.writeln("<success>Files page generated successfully</success>")
 
     def render_git_analysis_page(self, metrics: ProjectMetrics):
         """Render the git analysis page with comprehensive git data"""
-        if not metrics.git_metrics:
-            self.output.writeln("<success>No git metrics to render</success>")
-            return
-
-        def stringify_values(obj):
-            if isinstance(obj, dict):
-                return {key: stringify_values(value) for key, value in obj.items()}
-            elif isinstance(obj, list):
-                return [stringify_values(item) for item in obj]
-            else:
-                return str(obj)
-
         self.output.writeln("<info>Rendering git analysis page</info>")
-        try:
-            # Render git analysis template
-            self.render_template(
-                "git_analysis.html",
-                stringify_values(
-                    {
-                        "git_analysis": metrics.git_metrics.to_dict(),
-                        "git_analysis_json": json.dumps(
-                            metrics.git_metrics.get_contributors_dict(), indent=4
-                        ),
-                        "git_stats_data": json.dumps(
-                            metrics.git_metrics.get_commit_stats_per_month(), indent=4
-                        ),  # git commit graph
-                        "git_churn_data": json.dumps(
-                            metrics.git_metrics.get_churn_per_month(), indent=4
-                        ),  # git chrun graph
-                        "git_silos_data": metrics.git_metrics.get_silos_list()[
-                            :10
-                        ],  # silos list
-                        "git_contributors": metrics.git_metrics.get_contributors_list()[
-                            :10
-                        ],  # contributors list
-                        "git_hotspots_data": metrics.git_metrics.get_hotspots_list()[
-                            :10
-                        ],  # hotspots list
-                        "project_name": "Metripy",
-                        "last_updated": metrics.git_metrics.get_analysis_start_date(),
-                    }
-                ),
-            )
-
-            self.output.writeln(
-                "<success>Git analysis page generated successfully</success>"
-            )
-        except Exception as e:
-            raise e
-            self.output.writeln(
-                f"<error>Error generating git analysis page: {e}</error>"
-            )
+        self.page_renderer_factory.create_git_analysis_page_renderer().render(metrics)
+        self.output.writeln(
+            "<success>Git analysis page generated successfully</success>"
+        )
+
+    def render_dependencies_page(self, metrics: ProjectMetrics):
+        """Render the dependencies page with dependency details and stats"""
+        self.output.writeln("<info>Rendering dependencies page</info>")
+        self.page_renderer_factory.create_dependency_page_renderer().render(metrics)
+        self.output.writeln(
+            "<success>Dependencies page generated successfully</success>"
+        )
+
+    def render_trends_page(self, metrics: ProjectMetrics):
+        self.output.writeln("<info>Rendering trends page</info>")
+        self.page_renderer_factory.create_trends_page_renderer().render(metrics)
+        self.output.writeln("<success>Trends page generated successfully</success>")

metripy/Report/Html/TopOffendersPageRenderer.py

@@ -0,0 +1,84 @@
+from metripy.Metric.Code.Segmentor import Segmentor
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class TopOffendersPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def render(self, metrics: ProjectMetrics):
+        orderedByTotalCc = sorted(
+            metrics.file_metrics, key=lambda x: x.totalCc, reverse=True
+        )[:10]
+        orderedByMI = sorted(
+            metrics.file_metrics, key=lambda x: x.maintainabilityIndex, reverse=False
+        )[:10]
+        orderedByLoc = sorted(metrics.file_metrics, key=lambda x: x.loc, reverse=True)[
+            :10
+        ]
+
+        all_functions: list = []
+        for fm in metrics.file_metrics:
+            all_functions.extend(fm.function_nodes)
+
+        functionsOrderedByCc = sorted(
+            all_functions, key=lambda x: x.complexity, reverse=True
+        )[:10]
+        functionsOrderedByMi = sorted(
+            all_functions, key=lambda x: x.maintainability_index, reverse=False
+        )[:10]
+        functionsOrderedByLoc = sorted(
+            all_functions, key=lambda x: x.get_loc(), reverse=True
+        )[:10]
+
+        # TODO maintainability index per function, we dont calc yet
+
+        self.render_template(
+            "top_offenders.html",
+            {
+                "file_loc_offenders": [
+                    {**e.to_dict(), "status": Segmentor.get_loc_segment(e.loc)}
+                    for e in orderedByLoc
+                ],
+                "file_cc_offenders": [
+                    {
+                        **e.to_dict(),
+                        "status": Segmentor.get_complexity_segment(e.totalCc),
+                    }
+                    for e in orderedByTotalCc
+                ],
+                "file_mi_offenders": [
+                    {
+                        **e.to_dict(),
+                        "status": Segmentor.get_maintainability_segment(
+                            e.maintainabilityIndex
+                        ),
+                    }
+                    for e in orderedByMI
+                ],
+                "function_size_offenders": [
+                    {
+                        **e.to_dict(),
+                        "status": Segmentor.get_method_size_segment(e.get_loc()),
+                    }
+                    for e in functionsOrderedByLoc
+                ],
+                "function_cc_offenders": [
+                    {
+                        **e.to_dict(),
+                        "status": Segmentor.get_complexity_segment(e.complexity),
+                    }
+                    for e in functionsOrderedByCc
+                ],
+                "function_mi_offenders": [
+                    {
+                        **e.to_dict(),
+                        "status": Segmentor.get_maintainability_segment(
+                            e.maintainability_index
+                        ),
+                    }
+                    for e in functionsOrderedByMi
+                ],
+            },
+        )