metripy 0.2.5__py3-none-any.whl

src/Report/Json/GitJsonReporter.py

@@ -0,0 +1,21 @@
+from Report.Json.AbstractJsonReporter import AbstractJsonReporter
+from Metric.ProjectMetrics import ProjectMetrics
+
+
+class GitJsonReporter(AbstractJsonReporter):
+    def generate(self, metrics: ProjectMetrics) -> None:
+        if not metrics.git_metrics:
+            self.output.writeln(
+                "<error>Wants git json report, but no git metrics</error>"
+            )
+            return
+
+        data = {
+            "commits_per_month": metrics.git_metrics.get_commit_stats_per_month(),
+            "churn_data": metrics.git_metrics.get_churn_per_month(),
+            "possible_silos": metrics.git_metrics.get_silos_list()[:10],
+            "top_contributors": metrics.git_metrics.get_contributors_list()[:10],
+            "top_hotspots": metrics.git_metrics.get_hotspots_list()[:10],
+        }
+
+        self.put_data(data)

src/Report/Json/JsonReporter.py

@@ -0,0 +1,12 @@
+from Application.Config.Config import Config
+from Component.Output.CliOutput import CliOutput
+from Metric.ProjectMetrics import ProjectMetrics
+
+
+class JsonReporter:
+    def __init__(self, config: Config, output: CliOutput):
+        self.config = config
+        self.output = output
+
+    def generate(self, metrics: ProjectMetrics):
+        raise NotImplementedError

src/Report/ReporterFactory.py

@@ -0,0 +1,22 @@
+from Application.Config.ReportConfig import ReportConfig
+from Component.Output.CliOutput import CliOutput
+from Report import ReporterInterface
+from Report.Html.Reporter import Reporter as HtmlReporter
+from Report.Json.GitJsonReporter import GitJsonReporter
+
+
+class ReporterFactory:
+    @staticmethod
+    def create(config: ReportConfig, output: CliOutput) -> ReporterInterface:
+        if config.type == "html":
+            return HtmlReporter(config, output)
+        elif config.type == "json":
+            raise NotImplementedError
+        elif config.type == "csv":
+            raise NotImplementedError
+        elif config.type == "cli":
+            raise NotImplementedError
+        elif config.type == "json-git":
+            return GitJsonReporter(config, output)
+        else:
+            raise ValueError(f"Unsupported report type: {config.type}")

src/Report/ReporterInterface.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+from Metric.ProjectMetrics import ProjectMetrics
+from Application.Config.ReportConfig import ReportConfig
+from Component.Output.CliOutput import CliOutput
+
+
+class ReporterInterface(ABC):
+    def __init__(
+        self, config: ReportConfig, output: CliOutput, project_name: str = "foobar"
+    ):
+        self.config: ReportConfig = config
+        self.output = output
+
+    @abstractmethod
+    def generate(self, metrics: ProjectMetrics) -> None:
+        raise NotImplementedError()

src/Tree/ClassNode.py

@@ -0,0 +1,32 @@
+from Tree.FunctionNode import FunctionNode
+
+
+class ClassNode:
+    def __init__(
+        self,
+        full_name: str,
+        name: str,
+        lineno: int,
+        col_offset: int,
+        real_complexity: int,
+    ):
+        self.full_name = full_name
+        self.name = name
+        self.lineno = lineno
+        self.col_offset = col_offset
+        self.real_complexity = real_complexity
+        self.functions: list[FunctionNode] = []
+
+    def to_dict(self) -> dict:
+        """Convert ClassNode to a dictionary for JSON serialization."""
+        return {
+            "full_name": self.full_name,
+            "name": self.name,
+            "lineno": self.lineno,
+            "col_offset": self.col_offset,
+            "real_complexity": self.real_complexity,
+            "functions": [func.to_dict() for func in self.functions],
+        }
+
+    def __dict__(self) -> dict:
+        return self.to_dict()

src/Tree/FunctionNode.py

@@ -0,0 +1,49 @@
+class FunctionNode:
+    def __init__(
+        self, full_name: str, name: str, lineno: int, col_offset: int, complexity: int
+    ):
+        self.full_name = full_name
+        self.name = name
+        self.lineno = lineno
+        self.line_end = 0
+        self.col_offset = col_offset
+        self.complexity = complexity
+        self.h1 = 0
+        self.h2 = 0
+        self.N1 = 0
+        self.N2 = 0
+        self.vocabulary = 0
+        self.length = 0
+        self.calculated_length = 0
+        self.volume = 0
+        self.difficulty = 0
+        self.effort = 0
+        self.time = 0
+        self.bugs = 0
+        self.maintainability_index = 0
+
+    def to_dict(self) -> dict:
+        """Convert FunctionNode to a dictionary for JSON serialization."""
+        return {
+            "full_name": self.full_name,
+            "name": self.name,
+            "lineno": self.lineno,
+            "col_offset": self.col_offset,
+            "complexity": self.complexity,
+            "h1": self.h1,
+            "h2": self.h2,
+            "N1": self.N1,
+            "N2": self.N2,
+            "vocabulary": self.vocabulary,
+            "length": self.length,
+            "calculated_length": self.calculated_length,
+            "volume": self.volume,
+            "difficulty": self.difficulty,
+            "effort": self.effort,
+            "time": self.time,
+            "bugs": self.bugs,
+            "maintainability_index": self.maintainability_index,
+        }
+
+    def __dict__(self) -> dict:
+        return self.to_dict()

src/Tree/ModuleNode.py

@@ -0,0 +1,42 @@
+from Tree.ClassNode import ClassNode
+from Tree.FunctionNode import FunctionNode
+
+
+class ModuleNode:
+    def __init__(
+        self,
+        full_name: str,
+        loc: int,
+        lloc: int,
+        sloc: int,
+        comments: int,
+        multi: int,
+        blank: int,
+        single_comments: int,
+    ):
+        self.full_name = full_name
+        self.loc = loc
+        self.lloc = lloc
+        self.sloc = sloc
+        self.comments = comments
+        self.multi = multi
+        self.blank = blank
+        self.single_comments = single_comments
+        self.maintainability_index = 0
+        self.classes: list[ClassNode] = []
+        self.functions: list[FunctionNode] = []
+
+    def to_dict(self) -> dict:
+        return {
+            "full_name": self.full_name,
+            "loc": self.loc,
+            "lloc": self.lloc,
+            "sloc": self.sloc,
+            "comments": self.comments,
+            "multi": self.multi,
+            "blank": self.blank,
+            "single_comments": self.single_comments,
+            "maintainability_index": self.maintainability_index,
+            "classes": [c.to_dict() for c in self.classes],
+            "functions": [f.to_dict() for f in self.functions],
+        }

src/codemetrics.py

@@ -0,0 +1,15 @@
+#!/usr/bin/env python3
+"""main module"""
+import sys
+
+from Application.Application import Application
+
+
+def main():
+    """cli entry point to application"""
+    application = Application()
+    application.run(sys.argv)
+
+
+if __name__ == "__main__":
+    main()