metripy 0.2.7__py3-none-any.whl → 0.3.6__py3-none-any.whl

metripy/Report/Html/Reporter.py

@@ -1,14 +1,14 @@
-import json
 import os
 import shutil
+import sys
 from datetime import datetime
+from pathlib import Path
 
-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
 
 
@@ -18,12 +18,48 @@ class Reporter(ReporterInterface):
     ):
         self.config: ReportConfig = config
         self.output = output
-        self.template_dir = os.path.join(os.getcwd(), "templates/html_report")
+        
+        # Find templates directory - works both in development and when installed
+        template_dir = self._find_template_dir()
+        if not template_dir.exists():
+            raise FileNotFoundError(
+                f"Could not find templates directory. Searched in: "
+                f"{template_dir}"
+            )
+            
+        self.template_dir = str(template_dir)
+        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,
             "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         }
+    
+    def _find_template_dir(self) -> Path:
+        """Find the templates directory, checking multiple possible locations"""
+        package_dir = Path(__file__).parent.parent.parent  # metripy package root
+        
+        # List of possible locations to check
+        possible_locations = [
+            # Development: templates at project root
+            package_dir.parent / "templates" / "html_report",
+            # Alternative: templates inside metripy package
+            package_dir / "templates" / "html_report",
+            # System install location
+            Path(sys.prefix) / "share" / "metripy" / "templates" / "html_report",
+            # Fallback to cwd (for development)
+            Path.cwd() / "metripy" / "templates" / "html_report",
+        ]
+        
+        for location in possible_locations:
+            if location.exists() and (location / "index.html").exists():
+                return location
+        
+        return possible_locations[0]
 
     def generate(self, metrics: ProjectMetrics):
 
@@ -53,158 +89,63 @@ 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, "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": "CodeMetrics",
-                "last_updated": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "date": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                "author": "CodeMetrics",
-                "version": "1.0.0",
-            },
+        shutil.copytree(
+            os.path.join(self.template_dir, "images"),
+            os.path.join(self.config.path, "images"),
+            dirs_exist_ok=True,
         )
-        self.output.writeln("<success>Done rendering index page</success>")
+        # shutil.copytree(os.path.join(self.template_dir, "fonts"), os.path.join(self.config.path, "fonts"), dirs_exist_ok=True)
 
-        # 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 []
-
-        license_by_type = {}
-
-        # TODO render a pie chart
-        for dependency in dependencies:
-            for license_name in dependency.license:
-                if license_name not in license_by_type.keys():
-                    license_by_type[license_name] = 0
-                license_by_type[license_name] += 1
-
-        print(json.dumps(license_by_type, indent=2))
-
-        self.render_template(
-            "dependencies.html",
-            {
-                "dependencies": [d.to_dict() for d in dependencies],
-                "project_name": "CodeMetrics",
-                "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": "CodeMetrics",
-                "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": "CodeMetrics",
-                        "last_updated": metrics.git_metrics.get_analysis_start_date(),
-                    }
-                ),
-            )
+        self.page_renderer_factory.create_git_analysis_page_renderer().render(metrics)
+        self.output.writeln(
+            "<success>Git analysis page generated successfully</success>"
+        )
 
-            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>"
-            )
+    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
+                ],
+            },
+        )

metripy/Report/Html/TrendsPageRenderer.py

@@ -0,0 +1,137 @@
+from metripy.Metric.Code.FileMetrics import FileMetrics
+from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Html.PageRenderer import PageRenderer
+
+
+class TrendsPageRenderer(PageRenderer):
+    def __init__(self, template_dir: str, output_dir: str, project_name: str):
+        super().__init__(template_dir, output_dir, project_name)
+
+    def _compile_trend_item(self, file: FileMetrics) -> dict:
+        return {
+            "name": file.full_name,
+            "path": file.full_name,
+            "complexity_current": file.totalCc,
+            "complexity_prev": round(file.trend.historical_totalCc, 2),
+            "complexity_delta": round(file.trend.totalCc_delta, 2),
+            "maintainability_current": round(file.maintainabilityIndex, 2),
+            "maintainability_prev": round(
+                file.trend.historical_maintainabilityIndex, 2
+            ),
+            "maintainability_delta": round(file.trend.maintainabilityIndex_delta, 2),
+        }
+
+    def render(self, metrics: ProjectMetrics):
+        if metrics.total_code_metrics.trend is None:
+            self.render_template(
+                "trends.html",
+                {
+                    "has_trend_data": False,
+                    "trend_data": {
+                        "top_improved_complexity": [],
+                        "top_improved_maintainability": [],
+                        "top_worsened_complexity": [],
+                        "top_worsened_maintainability": [],
+                        "loc_segments_current": {},
+                        "loc_segments_prev": {},
+                        "complexity_segments_current": {},
+                        "complexity_segments_prev": {},
+                        "maintainability_segments_current": {},
+                        "maintainability_segments_prev": {},
+                        "method_size_segments_current": {},
+                        "method_size_segments_prev": {},
+                    },
+                },
+            )
+            return
+
+        # Top improved complexity (complexity went down - negative delta)
+        top_improved_complexity = [
+            x
+            for x in metrics.file_metrics
+            if x.trend is not None and x.trend.totalCc_delta < 0
+        ]
+        top_improved_complexity = sorted(
+            top_improved_complexity, key=lambda x: x.trend.totalCc_delta
+        )[:10]
+
+        # Top worsened complexity (complexity went up - positive delta)
+        top_worsened_complexity = [
+            x
+            for x in metrics.file_metrics
+            if x.trend is not None and x.trend.totalCc_delta > 0
+        ]
+        top_worsened_complexity = sorted(
+            top_worsened_complexity, key=lambda x: x.trend.totalCc_delta, reverse=True
+        )[:10]
+
+        # Top improved maintainability (maintainability went up - positive delta)
+        top_improved_maintainability = [
+            x
+            for x in metrics.file_metrics
+            if x.trend is not None and round(x.trend.maintainabilityIndex_delta, 2) > 0
+        ]
+        top_improved_maintainability = sorted(
+            top_improved_maintainability,
+            key=lambda x: x.trend.maintainabilityIndex_delta,
+            reverse=True,
+        )[:10]
+
+        # Top worsened maintainability (maintainability went down - negative delta)
+        top_worsened_maintainability = [
+            x
+            for x in metrics.file_metrics
+            if x.trend is not None and round(x.trend.maintainabilityIndex_delta, 2) < 0
+        ]
+        top_worsened_maintainability = sorted(
+            top_worsened_maintainability,
+            key=lambda x: x.trend.maintainabilityIndex_delta,
+        )[:10]
+
+        trend_data = {
+            # Segment distributions for each metric
+            "loc_segments_current": metrics.total_code_metrics.segmentation_data[
+                "loc"
+            ].to_dict_with_percent(),
+            "loc_segments_prev": metrics.total_code_metrics.trend.historical_segmentation_data[
+                "loc"
+            ].to_dict_with_percent(),
+            "complexity_segments_current": metrics.total_code_metrics.segmentation_data[
+                "complexity"
+            ].to_dict_with_percent(),
+            "complexity_segments_prev": metrics.total_code_metrics.trend.historical_segmentation_data[
+                "complexity"
+            ].to_dict_with_percent(),
+            "maintainability_segments_current": metrics.total_code_metrics.segmentation_data[
+                "maintainability"
+            ].to_dict_with_percent(),
+            "maintainability_segments_prev": metrics.total_code_metrics.trend.historical_segmentation_data[
+                "maintainability"
+            ].to_dict_with_percent(),
+            "method_size_segments_current": metrics.total_code_metrics.segmentation_data[
+                "methodSize"
+            ].to_dict_with_percent(),
+            "method_size_segments_prev": metrics.total_code_metrics.trend.historical_segmentation_data[
+                "methodSize"
+            ].to_dict_with_percent(),
+            "top_improved_complexity": [
+                self._compile_trend_item(x) for x in top_improved_complexity
+            ],
+            "top_improved_maintainability": [
+                self._compile_trend_item(x) for x in top_improved_maintainability
+            ],
+            "top_worsened_complexity": [
+                self._compile_trend_item(x) for x in top_worsened_complexity
+            ],
+            "top_worsened_maintainability": [
+                self._compile_trend_item(x) for x in top_worsened_maintainability
+            ],
+        }
+
+        self.render_template(
+            "trends.html",
+            {
+                "has_trend_data": metrics.total_code_metrics.trend is not None,
+                "trend_data": trend_data,
+            },
+        )

metripy/Report/Json/GitJsonReporter.py

@@ -19,3 +19,6 @@ class GitJsonReporter(AbstractJsonReporter):
         }
 
         self.put_data(data)
+        self.output.writeln(
+            f"<success>Create git json report in {self.config.path}</success>"
+        )

metripy/Report/Json/JsonReporter.py

@@ -1,12 +1,16 @@
 from metripy.Application.Config.Config import Config
 from metripy.Component.Output.CliOutput import CliOutput
 from metripy.Metric.ProjectMetrics import ProjectMetrics
+from metripy.Report.Json.AbstractJsonReporter import AbstractJsonReporter
 
 
-class JsonReporter:
+class JsonReporter(AbstractJsonReporter):
     def __init__(self, config: Config, output: CliOutput):
         self.config = config
         self.output = output
 
     def generate(self, metrics: ProjectMetrics):
-        raise NotImplementedError
+        self.put_data(metrics.to_dict())
+        self.output.writeln(
+            f"<success>Create json report in {self.config.path}</success>"
+        )

metripy/Report/ReporterFactory.py

@@ -3,15 +3,18 @@ from metripy.Component.Output.CliOutput import CliOutput
 from metripy.Report import ReporterInterface
 from metripy.Report.Html.Reporter import Reporter as HtmlReporter
 from metripy.Report.Json.GitJsonReporter import GitJsonReporter
+from metripy.Report.Json.JsonReporter import JsonReporter
 
 
 class ReporterFactory:
     @staticmethod
-    def create(config: ReportConfig, output: CliOutput) -> ReporterInterface:
+    def create(
+        config: ReportConfig, output: CliOutput, project_name: str
+    ) -> ReporterInterface:
         if config.type == "html":
-            return HtmlReporter(config, output)
+            return HtmlReporter(config, output, project_name)
         elif config.type == "json":
-            raise NotImplementedError
+            return JsonReporter(config, output)
         elif config.type == "csv":
             raise NotImplementedError
         elif config.type == "cli":

metripy/Tree/ClassNode.py

@@ -1,3 +1,7 @@
+from typing import Self
+
+from metripy.Metric.Code.Segmentor import Segmentor
+from metripy.Metric.Trend.ClassTrendMetric import ClassTrendMetric
 from metripy.Tree.FunctionNode import FunctionNode
 
 
@@ -17,6 +21,8 @@ class ClassNode:
         self.real_complexity = real_complexity
         self.functions: list[FunctionNode] = []
 
+        self.trend: ClassTrendMetric | None = None
+
     def to_dict(self) -> dict:
         """Convert ClassNode to a dictionary for JSON serialization."""
         return {
@@ -25,8 +31,23 @@ class ClassNode:
             "lineno": self.lineno,
             "col_offset": self.col_offset,
             "real_complexity": self.real_complexity,
+            "complexity_segment": Segmentor.get_complexity_segment(
+                self.real_complexity
+            ),
             "functions": [func.to_dict() for func in self.functions],
         }
 
     def __dict__(self) -> dict:
         return self.to_dict()
+
+    @staticmethod
+    def from_dict(data: dict) -> Self:
+        node = ClassNode(
+            full_name=data["full_name"],
+            name=data["name"],
+            lineno=data["lineno"],
+            col_offset=data["col_offset"],
+            real_complexity=data["real_complexity"],
+        )
+        node.functions = [FunctionNode.from_dict(d) for d in data["functions"]]
+        return node

metripy/Tree/FunctionNode.py

@@ -1,3 +1,10 @@
+import math
+from typing import Self
+
+from metripy.Metric.Code.Segmentor import Segmentor
+from metripy.Metric.Trend.FunctionTrendMetric import FunctionTrendMetric
+
+
 class FunctionNode:
     def __init__(
         self, full_name: str, name: str, lineno: int, col_offset: int, complexity: int
@@ -21,6 +28,35 @@ class FunctionNode:
         self.time = 0
         self.bugs = 0
         self.maintainability_index = 0
+        self.trend: FunctionTrendMetric | None = None
+
+    def get_loc(self) -> int:
+        return self.line_end - self.lineno
+
+    def calc_mi(self):
+
+        total_volume = self.volume
+        total_complexity = self.complexity
+        total_length = self.length
+
+        if total_volume == 0 or total_length == 0:
+            return 100.0
+
+        # PHP maintainability index calculation
+        mi_base = max(
+            (
+                171
+                - 5.2 * math.log(total_volume)
+                - 0.23 * total_complexity
+                - 16.2 * math.log(total_length)
+            )
+            * 100
+            / 171,
+            0,
+        )
+
+        # no comment weight
+        self.maintainability_index = mi_base
 
     def to_dict(self) -> dict:
         """Convert FunctionNode to a dictionary for JSON serialization."""
@@ -28,8 +64,12 @@ class FunctionNode:
             "full_name": self.full_name,
             "name": self.name,
             "lineno": self.lineno,
+            "line_end": self.line_end,
+            "loc": self.get_loc(),
+            "loc_segment": Segmentor.get_loc_segment(self.get_loc()),
             "col_offset": self.col_offset,
             "complexity": self.complexity,
+            "complexity_segment": Segmentor.get_complexity_segment(self.complexity),
             "h1": self.h1,
             "h2": self.h2,
             "N1": self.N1,
@@ -42,8 +82,33 @@ class FunctionNode:
             "effort": self.effort,
             "time": self.time,
             "bugs": self.bugs,
-            "maintainability_index": self.maintainability_index,
+            "maintainability_index": round(self.maintainability_index, 2),
+            "maintainability_segment": Segmentor.get_maintainability_segment(
+                self.maintainability_index
+            ),
         }
 
     def __dict__(self) -> dict:
         return self.to_dict()
+
+    @staticmethod
+    def from_dict(data: dict) -> Self:
+        node = FunctionNode(
+            full_name=data["full_name"],
+            name=data["name"],
+            lineno=data["lineno"],
+            col_offset=data["col_offset"],
+            complexity=data["complexity"],
+        )
+        node.line_end = data["line_end"]
+        node.vocabulary = data["vocabulary"]
+        node.length = data["length"]
+        node.calculated_length = data["calculated_length"]
+        node.volume = data["volume"]
+        node.difficulty = data["difficulty"]
+        node.effort = data["effort"]
+        node.time = data["time"]
+        node.bugs = data["bugs"]
+        node.maintainability_index = data["maintainability_index"]
+
+        return node