Develop (#3)

* refactor: separate analyzer and coverage logic

* feat: extract error message for better redability

* fix: more testing

Author: jungs1

pyproject.toml

@@ -8,8 +8,8 @@ universal = true
 
 
 [project]
-name = 'Mutahunter'
-description = "AI Language Agnostic Mutation Testing"
+name = 'mutahunter'
+description = "LLM Language Agnostic Mutation Testing"
 requires-python = ">= 3.11"
 version = "1.0.0"
 dependencies = [
@@ -28,7 +28,7 @@ dependencies = [
     'litellm',
 ]
 
-authors = [{ name = "Steven Jung", email = "[email protected]" }]
+authors = [{ name = "Steven Jung" }]
 
 [project.optional-dependencies]
 dev = ['isort', 'black']

src/mutahunter/core/analyzer.py

@@ -1,143 +1,27 @@
-import xml.etree.ElementTree as ET
 from importlib import resources
 from typing import Any, Dict, List
 
 from grep_ast import filename_to_lang
 from tree_sitter_languages import get_language, get_parser
 
-from mutahunter.core.entities.config import MutahunterConfig
 from mutahunter.core.logger import logger
 
 
 class Analyzer:
-    def __init__(self, config: MutahunterConfig) -> None:
-        """
-        Initializes the Analyzer with the given configuration.
-
-        Args:
-            config (Dict[str, Any]): The configuration dictionary.
-        """
-        self.config = config
-        self.line_rate = None
-        self.file_lines_executed = None
-
-    def run_coverage_analysis(self) -> Dict[str, List[int]]:
-        """
-        Parses the appropriate coverage report based on the coverage type.
-
-        Returns:
-            Dict[str, List[int]]: A dictionary where keys are filenames and values are lists of covered line numbers.
-        """
-        coverage_type_parsers = {
-            "cobertura": self.parse_coverage_report_cobertura,
-            "jacoco": self.parse_coverage_report_jacoco,
-            "lcov": self.parse_coverage_report_lcov,
-        }
-
-        if self.config.coverage_type in coverage_type_parsers:
-            return coverage_type_parsers[self.config.coverage_type]()
-        else:
-            raise ValueError(
-                "Invalid coverage tool. Please specify either 'cobertura', 'jacoco', or 'lcov'."
-            )
-
-    def parse_coverage_report_lcov(self) -> Dict[str, List[int]]:
-        """
-        Parses an LCOV code coverage report to extract covered line numbers for each file and calculate overall line coverage.
-
-        Returns:
-            Dict[str, Any]: A dictionary where keys are filenames and values are lists of covered line numbers.
-                            Additionally, it includes the overall line coverage percentage.
-        """
-        self.file_lines_executed = {}
-        current_file = None
-        total_lines_found = 0
-        total_lines_hit = 0
-
-        with open(self.config.code_coverage_report_path, "r") as file:
-            lines = file.readlines()
-            for line in lines:
-                if line.startswith("SF:"):
-                    current_file = line.strip().split(":", 1)[1]
-                    self.file_lines_executed[current_file] = []
-                elif line.startswith("DA:") and current_file:
-                    parts = line.strip().split(":")[1].split(",")
-                    hits = int(parts[1])
-                    if hits > 0:
-                        line_number = int(parts[0])
-                        self.file_lines_executed[current_file].append(line_number)
-                elif line.startswith("LF:") and current_file:
-                    total_lines_found += int(line.strip().split(":")[1])
-                elif line.startswith("LH:") and current_file:
-                    total_lines_hit += int(line.strip().split(":")[1])
-                elif line.startswith("end_of_record"):
-                    current_file = None
-        self.line_rate = (
-            (total_lines_hit / total_lines_found) if total_lines_found else 0.0
-        )
+    def __init__(self) -> None:
+        pass
 
-    def parse_coverage_report_cobertura(self) -> Dict[str, List[int]]:
+    def get_language_by_filename(self, filename: str) -> str:
         """
-        Parses a Cobertura XML code coverage report to extract covered line numbers for each file.
+        Gets the language identifier based on the filename.
 
-        Returns:
-            Dict[str, List[int]]: A dictionary where keys are filenames and values are lists of covered line numbers.
-        """
-        tree = ET.parse(self.config.code_coverage_report_path)
-        root = tree.getroot()
-        self.file_lines_executed = {}
-        self.line_rate = float(root.get("line-rate", 0))
-        for cls in root.findall(".//class"):
-            name_attr = cls.get("filename")
-            executed_lines = []
-            for line in cls.findall(".//line"):
-                line_number = int(line.get("number"))
-                hits = int(line.get("hits"))
-                if hits > 0:
-                    executed_lines.append(line_number)
-            if executed_lines:
-                self.file_lines_executed[name_attr] = executed_lines
-
-    def parse_coverage_report_jacoco(self) -> Dict[str, Any]:
-        """
-        Parses a JaCoCo XML code coverage report to extract covered line numbers for each file and calculate overall line coverage.
+        Args:
+            filename (str): The name of the file.
 
         Returns:
-            Dict[str, Any]: A dictionary where keys are file paths and values are lists of covered line numbers.
-                            Additionally, it includes the overall line coverage percentage.
+            str: The language identifier.
         """
-        tree = ET.parse(self.config.code_coverage_report_path)
-        root = tree.getroot()
-        self.file_lines_executed = {}
-
-        total_lines_missed = 0
-        total_lines_covered = 0
-
-        for package in root.findall(".//package"):
-            package_name = package.get("name").replace("/", ".")
-            for sourcefile in package.findall(".//sourcefile"):
-                filename = sourcefile.get("name")
-                # Construct the full file path with the src/main/java directory
-                full_filename = (
-                    f"src/main/java/{package_name.replace('.', '/')}/{filename}"
-                )
-                executed_lines = []
-                for line in sourcefile.findall(".//line"):
-                    line_number = int(line.get("nr"))
-                    missed = int(line.get("mi"))
-                    covered = int(line.get("ci"))
-                    if covered > 0:
-                        executed_lines.append(line_number)
-                    total_lines_missed += missed
-                    total_lines_covered += covered
-                if executed_lines:
-                    self.file_lines_executed[full_filename] = executed_lines
-
-        self.line_rate = (
-            (total_lines_covered / (total_lines_covered + total_lines_missed))
-            if (total_lines_covered + total_lines_missed) > 0
-            else 0.0
-        )
+        return filename_to_lang(filename)
 
     def get_covered_function_blocks(
         self, executed_lines: List[int], source_file_path: str
@@ -341,3 +225,57 @@ def _load_query_scm(self, lang: str) -> str:
         if not scm_fname.exists():
             return ""
         return scm_fname.read_text()
+
+    def find_function_block_by_name(
+        self, source_file_path: str, method_name: str
+    ) -> List[Any]:
+        """
+        Finds a function block by its name and returns the start and end lines of the function.
+
+        Args:
+            source_file_path (str): The path to the source file.
+            method_name (str): The name of the method to find.
+
+        Returns:
+            Dict[str, int]: A dictionary with 'start_line' and 'end_line' as keys and their corresponding line numbers as values.
+        """
+        source_code = self._read_source_file(source_file_path)
+        lang = filename_to_lang(source_file_path)
+        if lang is None:
+            raise ValueError(f"Language not supported for file: {source_file_path}")
+
+        parser = get_parser(lang)
+        language = get_language(lang)
+        tree = parser.parse(source_code)
+
+        query_scm = self._load_query_scm(lang)
+        if not query_scm:
+            raise ValueError(
+                "Failed to load query SCM file for the specified language."
+            )
+
+        query = language.query(query_scm)
+        captures = query.captures(tree.root_node)
+
+        result = []
+
+        for node, tag in captures:
+            if tag == "definition.function" or tag == "definition.method":
+                if self._is_function_name(node, method_name, source_code):
+                    return node
+        raise ValueError(f"Function {method_name} not found in file {source_file_path}")
+
+    def _is_function_name(self, node, method_name: str, source_code: bytes) -> bool:
+        """
+        Checks if the given node corresponds to the method_name.
+
+        Args:
+            node (Node): The AST node to check.
+            method_name (str): The method name to find.
+            source_code (bytes): The source code.
+
+        Returns:
+            bool: True if the node corresponds to the method_name, False otherwise.
+        """
+        node_text = source_code[node.start_byte : node.end_byte].decode("utf8")
+        return method_name in node_text