metripy 0.2.5__py3-none-any.whl

src/LangAnalyzer/Typescript/TypescriptAnalyzer.py

@@ -0,0 +1,210 @@
+import math
+
+import lizard
+
+from Component.Output.ProgressBar import ProgressBar
+from LangAnalyzer.AbstractLangAnalyzer import AbstractLangAnalyzer
+from LangAnalyzer.Typescript.TypescriptAstParser import TypescriptAstParser
+from LangAnalyzer.Typescript.TypescriptBasicComplexityAnalyzer import (
+    TypescriptBasicComplexityAnalzyer,
+)
+from LangAnalyzer.Typescript.TypescriptBasicLocAnalyzer import (
+    TypescriptBasicLocAnalyzer,
+)
+from LangAnalyzer.Typescript.TypescriptHalSteadAnalyzer import (
+    TypeScriptHalSteadAnalyzer,
+)
+from Tree.ClassNode import ClassNode
+from Tree.FunctionNode import FunctionNode
+from Tree.ModuleNode import ModuleNode
+
+
+class TypescriptAnalyzer(AbstractLangAnalyzer):
+
+    def __init__(self):
+        super().__init__()
+        self.ast_parser = TypescriptAstParser()
+        self.halstead_analyzer = TypeScriptHalSteadAnalyzer()
+        self.basic_complexity_analyzer = TypescriptBasicComplexityAnalzyer()
+
+    def get_lang_name(self) -> str:
+        return "Typescript"
+
+    def set_files(self, files: list[str]) -> None:
+        self.files = list(filter(lambda file: file.endswith((".ts", "js")), 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:
+        structure = self.ast_parser.extract_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 func_name in structure["functions"]:
+            full_name = self.full_name(filename, func_name)
+            try:
+                function_complexity_data = complexity_data[func_name]
+            except KeyError as e:
+                function_complexity_data = (
+                    self.basic_complexity_analyzer.get_complexity(code, func_name)
+                )
+                if function_complexity_data is None:
+                    print(
+                        f"error for function {full_name}: no lizard complexity data, basic analyzer also failed: '{e}'"
+                    )
+                    continue
+            function_node = FunctionNode(
+                full_name,
+                func_name,
+                function_complexity_data["start_line"],
+                0,
+                function_complexity_data["complexity"],
+            )
+            functions[full_name] = function_node
+
+        for class_name, method_names in structure["classes"].items():
+            full_name = self.full_name(filename, class_name)
+            class_node = ClassNode(
+                full_name,
+                class_name,
+                0,
+                0,
+                0.0,  # gets filled in later based on methods
+            )
+            classes[full_name] = class_node
+            for func_name in method_names:
+                full_name = self.full_name(filename, func_name, class_name)
+                try:
+                    function_complexity_data = complexity_data[func_name]
+                except KeyError as e:
+                    function_complexity_data = (
+                        self.basic_complexity_analyzer.get_complexity(code, func_name)
+                    )
+                    if function_complexity_data is None:
+                        print(
+                            f"error for method {full_name}: no lizard complexity data, basic analyzer also failed: '{e}'"
+                        )
+                        continue
+                function_node = FunctionNode(
+                    full_name,
+                    func_name,
+                    function_complexity_data["start_line"],
+                    function_complexity_data["end_line"],
+                    function_complexity_data["complexity"],
+                )
+                class_node.functions.append(function_node)
+                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 = TypescriptBasicLocAnalyzer.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):
+        return super().get_metrics()

src/LangAnalyzer/Typescript/TypescriptAstParser.py

@@ -0,0 +1,68 @@
+from collections import defaultdict
+
+from tree_sitter_languages import get_parser
+
+
+class TypescriptAstParser:
+    def __init__(self):
+        self.parser = get_parser("typescript")
+
+    def _get_node_text(self, code: str, node) -> str:
+        return code[node.start_byte : node.end_byte].decode("utf-8")
+
+    def extract_structure(self, code: str) -> dict:
+        tree = self.parser.parse(bytes(code, "utf8"))
+        root_node = tree.root_node
+        structure = defaultdict(list)
+        structure["classes"] = {}
+        structure["functions"] = []
+        structure["enums"] = []
+
+        def traverse(node, parent_class=None):
+            if node.type == "class_declaration":
+                class_name = None
+                for child in node.children:
+                    if child.type == "type_identifier":
+                        class_name = self._get_node_text(code.encode(), child)
+                        structure["classes"][class_name] = []
+                for child in node.children:
+                    traverse(child, class_name)
+
+            elif node.type == "method_definition" and parent_class:
+                for child in node.children:
+                    if child.type == "property_identifier":
+                        method_name = self._get_node_text(code.encode(), child)
+                        structure["classes"][parent_class].append(method_name)
+
+            elif node.type == "function_declaration":
+                for child in node.children:
+                    if child.type == "identifier":
+                        function_name = self._get_node_text(code.encode(), child)
+                        structure["functions"].append(function_name)
+
+            elif node.type == "lexical_declaration":
+                # Handle exported arrow functions like: export const foo = (...) => {...}
+                for child in node.children:
+                    if child.type == "variable_declarator":
+                        identifier = None
+                        for grandchild in child.children:
+                            if grandchild.type == "identifier":
+                                identifier = self._get_node_text(
+                                    code.encode(), grandchild
+                                )
+                            elif grandchild.type == "arrow_function":
+                                if identifier:
+                                    structure["functions"].append(identifier)
+
+            elif node.type == "enum_declaration":
+                enum_name = None
+                for child in node.children:
+                    if child.type == "identifier":
+                        enum_name = self._get_node_text(code.encode(), child)
+                        structure["enums"].append(enum_name)
+
+            for child in node.children:
+                traverse(child, parent_class)
+
+        traverse(root_node)
+        return dict(structure)

src/LangAnalyzer/Typescript/TypescriptBasicComplexityAnalyzer.py

@@ -0,0 +1,114 @@
+import re
+
+
+class TypescriptBasicComplexityAnalzyer:
+    def get_complexity(self, code: str, function_name: str) -> dict[str, int] | None:
+        function_scope = self._extract_function(code, function_name)
+        if not function_scope:
+            return None
+        (start_index, end_index, start_line, end_line) = function_scope
+        function_code = code[start_index:end_index]
+
+        complexity = self._determine_complexity(function_code)
+
+        return {
+            "start_line": start_line,
+            "end_line": end_line,
+            "complexity": complexity,
+        }
+
+    def _determine_complexity(self, function_code: str) -> int:
+        complexity = 1
+
+        # Keywords that increase complexity
+        keywords = [
+            r"\bif\b",
+            r"\bfor\b",
+            r"\bwhile\b",
+            r"\bcase\b",
+            r"\bcatch\b",
+            r"\?\s*",
+            r"\belse\s+if\b",
+            r"\breturn\b.*\?",
+            r"\bthrow\b.*\?",
+            r"&&",
+            r"\|\|",
+        ]
+
+        for keyword in keywords:
+            matches = re.findall(keyword, function_code)
+            complexity += len(matches)
+
+        return complexity
+
+    def _extract_function(
+        self, code: str, function_name: str
+    ) -> tuple[int, int, int, int] | None:
+        # This pattern matches various JavaScript/TypeScript function declarations:
+        # 1. Arrow functions:
+        #    - With or without `export`
+        #    - With or without `async`
+        #    - With or without generics (`<T>`)
+        #    - With or without return types (`: Type`)
+        #    - With multiline or single-line parameters
+        #    - Including curried arrow functions (arrow returning another arrow)
+        # 2. Traditional functions:
+        #    - With optional `export` and `async`
+        # 3. Class methods:
+        #    - With optional access modifiers (`public`, `private`, `protected`)
+        #    - With optional `static` and `async`
+        #    - With optional generics and return types
+        # 4. Bare class methods (no modifiers)
+
+        pattern = re.compile(
+            rf"""
+            (
+                (export\s+)?(const|let|var)\s+{re.escape(function_name)}\s*
+                (<[^>]*>)?\s*=\s*(async\s+)?\(\s*.*?\s*\)\s*
+                (:\s*[^=]+)?\s*=>\s*
+                (\s*\(\s*.*?\s*\)\s*=>)?\s*\{{?
+            )
+            |
+            (
+                (export\s+)?(async\s+)?function\s+{re.escape(function_name)}\s*
+                \(\s*.*?\s*\)\s*\{{ 
+            )
+            |
+            (
+                (?:public|private|protected)?\s*
+                (?:static\s+)?(?:async\s+)?{re.escape(function_name)}\s*
+                (<[^>]+>)?\s*\(\s*.*?\s*\)\s*
+                (:\s*[^\{{]+)?\s*\{{ 
+            )
+            |
+            (
+                {re.escape(function_name)}\s*\(\s*.*?\s*\)\s*\{{ 
+            )
+            """,
+            re.MULTILINE | re.DOTALL | re.VERBOSE,
+        )
+
+        match = pattern.search(code)
+        if not match:
+            print(f"Function '{function_name}' not found.")
+            return None
+
+        start_index = match.start()
+        start_line = code[:start_index].count("\n") + 1
+
+        # Find the matching closing brace
+        brace_count = 0
+        i = match.end() - 1
+        while i < len(code):
+            if code[i] == "{":
+                brace_count += 1
+            elif code[i] == "}":
+                brace_count -= 1
+                if brace_count == 0:
+                    end_index = i + 1
+                    end_line = code[:end_index].count("\n") + 1
+                    return (start_index, end_index, start_line, end_line)
+            i += 1
+
+        print(f"Function '{function_name}' seems to be incomplete or malformed.")
+        return None

src/LangAnalyzer/Typescript/TypescriptBasicLocAnalyzer.py

@@ -0,0 +1,69 @@
+class TypescriptBasicLocAnalyzer:
+    @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 = TypescriptBasicLocAnalyzer._count_blank_lines(lines)
+            comment_lines = TypescriptBasicLocAnalyzer._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

src/LangAnalyzer/Typescript/TypescriptHalSteadAnalyzer.py

@@ -0,0 +1,55 @@
+from LangAnalyzer.Generic.HalSteadAnalyzer import HalSteadAnalyzer
+
+
+class TypeScriptHalSteadAnalyzer:
+    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/Metric/Code/AggregatedMetrics.py

@@ -0,0 +1,42 @@
+from Metric.Code.SegmentedMetrics import SegmentedMetrics
+
+
+class AggregatedMetrics:
+    """Used to show aggregated metrics on the index page"""
+
+    def __init__(
+        self,
+        loc: int = 0,
+        avgCcPerFunction: float = 0.0,
+        maintainabilityIndex: float = 0.0,
+        avgLocPerFunction: float = 0.0,
+        num_files: int = 0,
+        segmented_loc: SegmentedMetrics = SegmentedMetrics(),
+        segmented_complexity: SegmentedMetrics = SegmentedMetrics(),
+        segmented_maintainability: SegmentedMetrics = SegmentedMetrics(),
+        segmented_method_size: SegmentedMetrics = SegmentedMetrics(),
+    ) -> None:
+        self.loc = loc
+        self.avgCcPerFunction = avgCcPerFunction
+        self.maintainabilityIndex = maintainabilityIndex
+        self.avgLocPerFunction = avgLocPerFunction
+        self.num_files = num_files
+
+        self.segmentation_data = {
+            "loc": segmented_loc,
+            "complexity": segmented_complexity,
+            "maintainability": segmented_maintainability,
+            "methodSize": segmented_method_size,
+        }
+
+    def to_dict(self) -> dict:
+        return {
+            "loc": str(self.loc),
+            "avgCcPerFunction": f"{self.avgCcPerFunction:.2f}",
+            "maintainabilityIndex": f"{self.maintainabilityIndex:.2f}",
+            "avgLocPerFunction": f"{self.avgLocPerFunction:.2f}",
+            "num_files": str(self.num_files),
+        }
+
+    def to_dict_segmentation(self) -> dict:
+        return {k: v.to_dict() for k, v in self.segmentation_data.items()}

src/Metric/Code/FileMetrics.py

@@ -0,0 +1,33 @@
+from Tree.ClassNode import ClassNode
+from Tree.FunctionNode import FunctionNode
+
+
+class FileMetrics:
+    def __init__(
+        self,
+        full_name: str,
+        loc: int,
+        avgCcPerFunction: float,
+        maintainabilityIndex: float,
+        avgLocPerFunction: float,
+        class_nodes: list[ClassNode],
+        function_nodes: list[FunctionNode],
+    ):
+        self.full_name = full_name
+        self.loc = loc
+        self.avgCcPerFunction = avgCcPerFunction
+        self.maintainabilityIndex = maintainabilityIndex
+        self.avgLocPerFunction = avgLocPerFunction
+        self.class_nodes = class_nodes
+        self.function_nodes = function_nodes
+
+    def to_dict(self) -> dict:
+        return {
+            "full_name": self.full_name,
+            "loc": self.loc,
+            "avgCcPerFunction": self.avgCcPerFunction,
+            "maintainabilityIndex": f"{self.maintainabilityIndex:.2f}",
+            "avgLocPerFunction": self.avgLocPerFunction,
+            "class_nodes": [node.to_dict() for node in self.class_nodes],
+            "function_nodes": [node.to_dict() for node in self.function_nodes],
+        }

src/Metric/Code/ModuleMetrics.py

@@ -0,0 +1,32 @@
+from Tree.ClassNode import ClassNode
+from Tree.FunctionNode import FunctionNode
+
+
+class ModuleMetrics:
+    def __init__(
+        self,
+        loc: int,
+        avgCcPerFunction: float,
+        maintainabilityIndex: float,
+        avgLocPerFunction: float,
+        class_nodes: list[ClassNode],
+        function_nodes: list[FunctionNode],
+    ):
+        self.loc = loc
+        self.avgCcPerFunction = avgCcPerFunction
+        self.maintainabilityIndex = maintainabilityIndex
+        self.avgLocPerFunction = avgLocPerFunction
+        self.num_files = 1
+        self.class_nodes: list[ClassNode] = class_nodes
+        self.function_nodes: list[FunctionNode] = function_nodes
+
+    def to_dict(self) -> dict:
+        return {
+            "loc": str(self.loc),
+            "avgCcPerFunction": f"{self.avgCcPerFunction:.2f}",
+            "maintainabilityIndex": f"{self.maintainabilityIndex:.2f}",
+            "avgLocPerFunction": f"{self.avgLocPerFunction:.2f}",
+            "num_files": str(self.num_files),
+            "class_nodes": [node.to_dict() for node in self.class_nodes],
+            "function_nodes": [node.to_dict() for node in self.function_nodes],
+        }