metripy 0.2.5__py3-none-any.whl

src/LangAnalyzer/Php/PhpAnalyzer.py

@@ -0,0 +1,193 @@
+import math
+from pathlib import Path
+
+import lizard
+
+from Component.Output.ProgressBar import ProgressBar
+from LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
+from LangAnalyzer.Php.PhpBasicAstParser import PhpBasicAstParser
+from LangAnalyzer.Php.PhpBasicLocAnalyzer import PhpBasicLocAnalyzer
+from LangAnalyzer.Php.PhpHalSteadAnalyzer import PhpHalSteadAnalyzer
+from Metric.Code.FileMetrics import FileMetrics
+from Tree.ClassNode import ClassNode
+from Tree.FunctionNode import FunctionNode
+from Tree.ModuleNode import ModuleNode
+
+
+class PhpAnalyzer(AbstractLangAnalyzer):
+    def __init__(self):
+        super().__init__()
+        self.loc_analyzer = PhpBasicLocAnalyzer()
+        self.halstead_analyzer = PhpHalSteadAnalyzer()
+
+    def get_lang_name(self) -> str:
+        return "PHP"
+
+    def set_files(self, files: list[str]) -> None:
+        self.files = list(filter(lambda file: file.endswith(".php"), files))
+
+    def is_needed(self) -> bool:
+        return len(self.files) > 0
+
+    def run(self, progress_bar: ProgressBar) -> None:
+        for file in self.files:
+            with open(file, "r") as f:
+                code = f.read()
+                self.analyze(code, file)
+            progress_bar.advance()
+
+    @staticmethod
+    def full_name(
+        filename: str, item_name: str | None = None, class_name: str | None = None
+    ) -> str:
+        if class_name is None:
+            if item_name is None:
+                return filename
+            return f"{filename}:{item_name}"
+        return f"{filename}:{class_name}:{item_name}"
+
+    def analyze(self, code: str, filename: str) -> None:
+        file_stem = Path(filename).stem
+        structure = PhpBasicAstParser.parse_php_structure(code)
+
+        lizard_result = lizard.analyze_file(filename)
+        complexity_data = {
+            func.name: {
+                "complexity": func.cyclomatic_complexity,
+                "start_line": func.start_line,
+                "end_line": func.end_line,
+            }
+            for func in lizard_result.function_list
+        }
+
+        classes: dict[str, ClassNode] = {}
+        functions: dict[str, FunctionNode] = {}
+        for obj in structure:
+            if obj["type"] == "class":
+                full_name = self.full_name(filename, obj["name"])
+                classes[full_name] = ClassNode(
+                    full_name,
+                    obj["name"],
+                    obj["line"],
+                    0,
+                    0,  # gets filled in later, based on methods
+                )
+            elif obj["type"] == "method" or obj["type"] == "function":
+                full_name = self.full_name(filename, obj["name"])
+                try:
+                    function_node = FunctionNode(
+                        full_name,
+                        obj["name"],
+                        obj["line"],
+                        0,
+                        complexity_data[f"{file_stem}::{obj['name']}"]["complexity"],
+                    )
+                    function_node.line_end = complexity_data[
+                        f"{file_stem}::{obj['name']}"
+                    ]["end_line"]
+                except KeyError:
+                    # no complexity data, function must be empty
+                    function_node = FunctionNode(
+                        full_name,
+                        obj["name"],
+                        obj["line"],
+                        0,
+                        0,
+                    )
+
+                if obj["type"] == "method":
+                    class_name = obj["class"]
+                    full_class_name = self.full_name(filename, class_name)
+                    class_node = classes.get(full_class_name)
+                    if class_node is not None:
+                        class_node.functions.append(function_node)
+                    else:
+                        raise ValueError(
+                            f"Class node not found for function {full_class_name}"
+                        )
+                functions[full_name] = function_node
+
+        # complexity of classes
+        for class_node in classes.values():
+            class_node.real_complexity = sum(
+                [func.complexity for func in class_node.functions]
+            )
+
+        loc_data = self.loc_analyzer.get_loc_metrics(code, filename)
+
+        full_name = self.full_name(filename)
+        module_node = ModuleNode(
+            full_name,
+            loc_data.get("lines", 0),
+            loc_data.get("linesOfCode", 0),
+            loc_data.get("logicalLinesOfCode", 0),
+            loc_data.get("commentLines", 0),
+            0,  # multi-line comments - not directly available
+            loc_data.get("linesOfCode", 0) - loc_data.get("logicalLinesOfCode", 0),
+            loc_data.get("commentLines", 0),
+        )
+        module_node.classes.extend(classes.values())
+        module_node.functions.extend(functions.values())
+
+        code_lines = code.split("\n")
+        for func_name, function_node in functions.items():
+            lines = code_lines[function_node.lineno : function_node.line_end]
+            function_metrics = self.halstead_analyzer.calculate_halstead_metrics(
+                "\n".join(lines)
+            )
+            function_node.h1 = function_metrics["n1"]
+            function_node.h2 = function_metrics["n2"]
+            function_node.N1 = function_metrics["N1"]
+            function_node.N2 = function_metrics["N2"]
+            function_node.vocabulary = function_metrics["vocabulary"]
+            function_node.length = function_metrics["length"]
+            function_node.volume = function_metrics["volume"]
+            function_node.difficulty = function_metrics["difficulty"]
+            function_node.effort = function_metrics["effort"]
+            function_node.calculated_length = function_metrics["calculated_length"]
+            function_node.bugs = function_metrics["bugs"]
+            function_node.time = function_metrics["time"]
+
+        maintainability_index = self._calculate_maintainability_index(
+            functions.values(), module_node
+        )
+        module_node.maintainability_index = maintainability_index
+        self.modules[full_name] = module_node
+
+    def _calculate_maintainability_index(
+        self, functions: list[FunctionNode], module_node: ModuleNode
+    ) -> float:
+        """Calculate maintainability index for PHP"""
+        if not functions:
+            return 100.0
+
+        total_volume = sum(func.volume for func in functions)
+        total_complexity = sum(func.complexity for func in functions)
+        total_length = sum(func.length for func in functions)
+
+        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,
+        )
+
+        # Comment weight
+        comment_weight = 0
+        if module_node.loc > 0:
+            comment_ratio = module_node.single_comments / module_node.loc
+            comment_weight = 50 * math.sin(math.sqrt(2.4 * comment_ratio))
+
+        return mi_base + comment_weight
+
+    def get_metrics(self) -> list[FileMetrics]:
+        return super().get_metrics()

src/LangAnalyzer/Php/PhpBasicAstParser.py

@@ -0,0 +1,56 @@
+import re
+
+
+class PhpBasicAstParser:
+
+    @staticmethod
+    def parse_php_structure(code: str):
+
+        # Regex patterns
+        class_pattern = re.compile(r"class\s+(\w*)")
+        interface_pattern = re.compile(r"interface\s+(\w*)")
+        method_pattern = re.compile(r"function\s+(\w+)\s*\([^)]*\)?")
+        function_pattern = re.compile(r"function\s+(\w+)\s*\([^)]*\)?")
+
+        lines = code.split("\n")
+        structure = []
+        current_class = None
+
+        for i, line in enumerate(lines):
+            class_match = class_pattern.search(line)
+            if class_match:
+                current_class = class_match.group(1)
+                structure.append(
+                    {"type": "class", "name": current_class, "line": i + 1}
+                )
+
+            interface_match = interface_pattern.search(line)
+            if interface_match:
+                current_class = interface_match.group(1)
+                structure.append(
+                    {
+                        "type": "class",
+                        "type_type": "interface",
+                        "name": current_class,
+                        "line": i + 1,
+                    }
+                )
+
+            method_match = method_pattern.search(line)
+            if method_match and current_class:
+                structure.append(
+                    {
+                        "type": "method",
+                        "name": method_match.group(1),
+                        "class": current_class,
+                        "line": i + 1,
+                    }
+                )
+
+            elif function_pattern.search(line) and not current_class:
+                function_name = function_pattern.search(line).group(1)
+                structure.append(
+                    {"type": "function", "name": function_name, "line": i + 1}
+                )
+
+        return structure

src/LangAnalyzer/Php/PhpBasicLocAnalyzer.py

@@ -0,0 +1,174 @@
+import re
+
+
+class PhpBasicLocAnalyzer:
+    @staticmethod
+    def get_loc_metrics(code: str, filename: str) -> dict:
+        """Fallback LOC calculation using manual analysis"""
+        try:
+            lines = code.split("\n")
+
+            total_lines = len(lines)
+            blank_lines = PhpBasicLocAnalyzer._count_blank_lines(lines)
+            comment_lines = PhpBasicLocAnalyzer._count_comment_lines(lines)
+            code_lines = total_lines - blank_lines - comment_lines
+
+            return {
+                "lines": total_lines,
+                "linesOfCode": code_lines,
+                "logicalLinesOfCode": code_lines,
+                "commentLines": comment_lines,
+                "blankLines": blank_lines,
+            }
+        except Exception as e:
+            print(f"Fallback LOC analysis failed: {e}")
+            return {
+                "lines": 0,
+                "linesOfCode": 0,
+                "logicalLinesOfCode": 0,
+                "commentLines": 0,
+                "blankLines": 0,
+            }
+
+    @staticmethod
+    def _count_blank_lines(lines: list) -> int:
+        """Count blank lines"""
+        return sum(1 for line in lines if not line.strip())
+
+    @staticmethod
+    def _count_comment_lines(lines: list) -> int:
+        """Count comment lines (single-line and multi-line)"""
+        comment_count = 0
+        in_multiline_comment = False
+
+        for line in lines:
+            stripped = line.strip()
+
+            # Handle multi-line comments
+            if "/*" in stripped:
+                in_multiline_comment = True
+                comment_count += 1
+                # Check if comment closes on same line
+                if "*/" in stripped:
+                    in_multiline_comment = False
+                continue
+
+            if in_multiline_comment:
+                comment_count += 1
+                if "*/" in stripped:
+                    in_multiline_comment = False
+                continue
+
+            # Handle single-line comments
+            if stripped.startswith(("//")) or stripped.startswith("#"):
+                comment_count += 1
+                continue
+
+            # Handle doc comments
+            if stripped.startswith("*") and not stripped.startswith("*/"):
+                comment_count += 1
+                continue
+
+        return comment_count
+
+    def _count_classes(self, lines: list) -> int:
+        """Count class definitions"""
+        content = "".join(lines)
+        class_pattern = r"(?:abstract\s+)?class\s+\w+"
+        return len(re.findall(class_pattern, content, re.IGNORECASE))
+
+    def _count_functions(self, lines: list) -> int:
+        """Count all function definitions (including methods)"""
+        content = "".join(lines)
+        func_pattern = (
+            r"(?:public\s+|private\s+|protected\s+)?(?:static\s+)?function\s+\w+"
+        )
+        return len(re.findall(func_pattern, content, re.IGNORECASE))
+
+    def _count_methods(self, lines: list) -> int:
+        """Count class methods (functions inside classes)"""
+        content = "".join(lines)
+
+        # This is a simplified approach - count functions that appear after class declarations
+        class_positions = []
+        for match in re.finditer(r"class\s+\w+", content, re.IGNORECASE):
+            class_positions.append(match.start())
+
+        if not class_positions:
+            return 0
+
+        method_count = 0
+        for match in re.finditer(
+            r"(?:public\s+|private\s+|protected\s+)?(?:static\s+)?function\s+\w+",
+            content,
+            re.IGNORECASE,
+        ):
+            func_pos = match.start()
+            # Check if this function is after any class declaration
+            for class_pos in class_positions:
+                if func_pos > class_pos:
+                    method_count += 1
+                    break
+
+        return method_count
+
+    def _count_constants(self, lines: list) -> int:
+        """Count constants (const and define)"""
+        content = "".join(lines)
+
+        # Count const declarations
+        const_pattern = r"\bconst\s+\w+"
+        const_count = len(re.findall(const_pattern, content, re.IGNORECASE))
+
+        # Count define() calls
+        define_pattern = r"\bdefine\s*\("
+        define_count = len(re.findall(define_pattern, content, re.IGNORECASE))
+
+        return const_count + define_count
+
+    def analyze_code_structure(self, filepath: str) -> dict:
+        """Analyze the overall structure of the PHP file"""
+        try:
+            with open(filepath, "r") as f:
+                content = f.read()
+
+            # Count various PHP constructs
+            structure = {
+                "namespaces": len(
+                    re.findall(r"namespace\s+[\w\\]+", content, re.IGNORECASE)
+                ),
+                "use_statements": len(
+                    re.findall(r"use\s+[\w\\]+", content, re.IGNORECASE)
+                ),
+                "interfaces": len(
+                    re.findall(r"interface\s+\w+", content, re.IGNORECASE)
+                ),
+                "traits": len(re.findall(r"trait\s+\w+", content, re.IGNORECASE)),
+                "abstract_classes": len(
+                    re.findall(r"abstract\s+class\s+\w+", content, re.IGNORECASE)
+                ),
+                "final_classes": len(
+                    re.findall(r"final\s+class\s+\w+", content, re.IGNORECASE)
+                ),
+                "magic_methods": len(
+                    re.findall(r"function\s+__\w+", content, re.IGNORECASE)
+                ),
+                "static_methods": len(
+                    re.findall(r"static\s+function\s+\w+", content, re.IGNORECASE)
+                ),
+                "private_methods": len(
+                    re.findall(r"private\s+function\s+\w+", content, re.IGNORECASE)
+                ),
+                "protected_methods": len(
+                    re.findall(r"protected\s+function\s+\w+", content, re.IGNORECASE)
+                ),
+                "public_methods": len(
+                    re.findall(r"public\s+function\s+\w+", content, re.IGNORECASE)
+                ),
+            }
+
+            return structure
+
+        except Exception as e:
+            print(f"Code structure analysis failed: {e}")
+            return {}

src/LangAnalyzer/Php/PhpHalSteadAnalyzer.py

@@ -0,0 +1,44 @@
+from LangAnalyzer.Generic.HalSteadAnalyzer import HalSteadAnalyzer
+
+
+class PhpHalSteadAnalyzer:
+    def __init__(self):
+        self.operators = set(
+            [
+                "+",
+                "-",
+                "*",
+                "/",
+                "%",
+                "++",
+                "--",
+                "=",
+                "==",
+                "!=",
+                "===",
+                "!==",
+                "<",
+                ">",
+                "<=",
+                ">=",
+                "&&",
+                "||",
+                "!",
+                ".",
+                "->",
+                "=>",
+                "::",
+                "?",
+                ":",
+                "&",
+                "|",
+                "^",
+                "~",
+                "<<",
+                ">>",
+            ]
+        )
+        self.analyzer = HalSteadAnalyzer(self.operators)
+
+    def calculate_halstead_metrics(self, code: str):
+        return self.analyzer.calculate_halstead_metrics(code)

src/LangAnalyzer/Python/PythonAnalyzer.py

@@ -0,0 +1,129 @@
+from radon.complexity import cc_visit
+from radon.metrics import Halstead, HalsteadReport, h_visit, mi_visit
+from radon.raw import analyze
+from radon.visitors import Class, Function
+
+from Component.Output.ProgressBar import ProgressBar
+from LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
+from Metric.Code.FileMetrics import FileMetrics
+from Tree.ClassNode import ClassNode
+from Tree.FunctionNode import FunctionNode
+from Tree.ModuleNode import ModuleNode
+
+
+class PythonAnalyzer(AbstractLangAnalyzer):
+
+    def __init__(self):
+        super().__init__()
+
+    def get_lang_name(self) -> str:
+        return "Python"
+
+    def set_files(self, files: list[str]) -> None:
+        self.files = list(filter(lambda file: file.endswith(".py"), files))
+
+    def is_needed(self) -> bool:
+        return len(self.files) > 0
+
+    def run(self, progress_bar: ProgressBar) -> None:
+        for file in self.files:
+            with open(file, "r") as f:
+                code = f.read()
+                self.analyze(code, file)
+            progress_bar.advance()
+
+    @staticmethod
+    def full_name(
+        filename: str, item_name: str | None = None, class_name: str | None = None
+    ) -> str:
+        if class_name is None:
+            if item_name is None:
+                return filename
+            return f"{filename}:{item_name}"
+        return f"{filename}:{class_name}:{item_name}"
+
+    def analyze(self, code: str, filename: str) -> None:
+        classes: dict[str, ClassNode] = {}
+        functions: dict[str, FunctionNode] = {}
+        cc = cc_visit(code)
+        for item in cc:
+            if isinstance(item, Class):
+                full_name = self.full_name(filename, item.name)
+                classes[full_name] = ClassNode(
+                    full_name,
+                    item.name,
+                    item.lineno,
+                    item.col_offset,
+                    item.real_complexity,
+                )
+            elif isinstance(item, Function):
+                full_class_name = self.full_name(filename, item.classname)
+                full_name = self.full_name(filename, item.name)
+                function_node = FunctionNode(
+                    full_name, item.name, item.lineno, item.col_offset, item.complexity
+                )
+                if item.is_method:
+                    class_node = classes.get(full_class_name)
+                    if class_node is not None:
+                        class_node.functions.append(function_node)
+                    else:
+                        raise ValueError(
+                            f"Class node not found for function {full_class_name}"
+                        )
+                functions[full_name] = function_node
+            else:
+                raise ValueError(f"Unknown item type: {type(item)}")
+
+        # print("--------------------------------")
+        # print(json.dumps([c.__dict__() for c in classes.values()], indent=4))
+        # print("--------------------------------")
+        # print(json.dumps([f.__dict__() for f in functions.values()], indent=4))
+        # exit()
+        module = analyze(code)
+        full_name = self.full_name(filename)
+        module_node = ModuleNode(
+            full_name,
+            module.loc,
+            module.lloc,
+            module.sloc,
+            module.comments,
+            module.multi,
+            module.blank,
+            module.single_comments,
+        )
+        module_node.classes.extend(classes.values())
+        module_node.functions.extend(functions.values())
+        # print(module)
+        # print(json.dumps([m.to_dict() for m in modules.values()], indent=4))
+        # exit()
+        h = h_visit(code)
+        assert isinstance(h, Halstead)
+        # print(h.total)
+        function_name: str
+        report: HalsteadReport
+        for function_name, report in h.functions:
+            full_name = self.full_name(filename, function_name)
+            function_node = functions.get(full_name)
+            if function_node is not None:
+                function_node.h1 = report.h1
+                function_node.h2 = report.h2
+                function_node.N1 = report.N1
+                function_node.N2 = report.N2
+                function_node.vocabulary = report.vocabulary
+                function_node.length = report.length
+                function_node.calculated_length = report.calculated_length
+                function_node.volume = report.volume
+                function_node.difficulty = report.difficulty
+                function_node.effort = report.effort
+                function_node.bugs = report.bugs
+                function_node.time = report.time
+            else:
+                raise ValueError(f"Function node not found for function {full_name}")
+
+        maintainability_index = mi_visit(code, True)
+        module_node.maintainability_index = maintainability_index
+
+        self.modules[full_name] = module_node
+
+    def get_metrics(self) -> list[FileMetrics]:
+        return super().get_metrics()