graph-dependency-analyzer 0.2.0__py3-none-any.whl

src/infrastructure/parsing/tree_sitter_java_parser.py

@@ -0,0 +1,434 @@
+"""TreeSitterJavaParser - Real Tree-sitter based Java AST parser.
+
+Uses tree-sitter and tree-sitter-java for precise AST parsing via tree traversal.
+"""
+import re
+from pathlib import Path
+from typing import Any
+
+from tree_sitter import Language, Parser, Node
+import tree_sitter_java
+
+from src.domain.repositories.i_code_parser import ICodeParser, ParseResult
+
+
+class ParseError(Exception):
+    """Exception raised when parsing fails."""
+    pass
+
+
+class TreeSitterJavaParser:
+    """
+    Java parser implementation using Tree-sitter library.
+
+    Extracts AST structures from Java source code using tree traversal.
+    """
+
+    # Regex patterns for URL and JDBC detection
+    URL_PATTERN = re.compile(r'https?://[^\s"\'<>]+')
+    JDBC_PATTERN = re.compile(r'jdbc:([^:]+)://([^:/\s"\']+):?(\d+)?/([^\s"\']+)')
+
+    def __init__(self):
+        """Initialize Tree-sitter parser with Java grammar."""
+        # Load Java language
+        self.language = Language(tree_sitter_java.language())
+        self.parser = Parser(self.language)
+
+    def parse_file(self, file_path: Path) -> ParseResult:
+        """
+        Parse a Java file and extract AST structures using real tree-sitter.
+
+        Args:
+            file_path: Path to Java file
+
+        Returns:
+            ParseResult with extracted structures
+
+        Raises:
+            FileNotFoundError: If file doesn't exist
+            ParseError: If parsing fails
+        """
+        if not file_path.exists():
+            raise FileNotFoundError(f"File not found: {file_path}")
+
+        try:
+            code_bytes = file_path.read_bytes()
+            code_str = code_bytes.decode('utf-8')
+        except Exception as e:
+            raise ParseError(f"Failed to read file: {e}")
+
+        # Parse with tree-sitter - REAL AST PARSING
+        tree = self.parser.parse(code_bytes)
+
+        # Check for parse errors
+        if tree.root_node.has_error:
+            raise ParseError(f"Syntax errors in Java file: {file_path}")
+
+        # Extract structures via tree traversal
+        package = self._extract_package(tree.root_node, code_str)
+        classes = self._extract_classes(tree.root_node, code_str, package)
+        methods = self._extract_methods(tree.root_node, code_str, package)
+        imports = self._extract_imports(tree.root_node, code_str)
+        string_literals = self._extract_string_literals(tree.root_node, code_str)
+        method_calls = self._extract_method_calls(tree.root_node, code_str)
+        endpoints = self._extract_spring_endpoints(tree.root_node, code_str, package)
+
+        # Attach endpoints as extra_data on method_calls so the pipeline can pick them up
+        for ep in endpoints:
+            method_calls.append({**ep, "_is_endpoint": True})
+
+        return ParseResult(
+            file_path=file_path,
+            classes=classes,
+            methods=methods,
+            imports=imports,
+            method_calls=method_calls,
+            string_literals=string_literals
+        )
+
+    def _extract_package(self, root: Node, code: str) -> str:
+        """Extract package declaration by traversing AST."""
+        for child in root.children:
+            if child.type == "package_declaration":
+                for subchild in child.children:
+                    if subchild.type == "scoped_identifier":
+                        return self._get_node_text(subchild, code)
+        return ""
+
+    def _extract_classes(self, root: Node, code: str, package: str) -> list[dict]:
+        """Extract class and interface declarations by traversing AST."""
+        classes = []
+        self._find_classes_recursive(root, code, package, classes)
+        return classes
+
+    def _find_classes_recursive(self, node: Node, code: str, package: str, results: list):
+        """Recursively find class and interface declarations."""
+        if node.type == "class_declaration":
+            for child in node.children:
+                if child.type == "identifier":
+                    class_name = self._get_node_text(child, code)
+                    qualified_name = f"{package}.{class_name}" if package else class_name
+                    results.append({
+                        "name": class_name,
+                        "qualified_name": qualified_name,
+                        "type": "class",
+                        "line": child.start_point[0] + 1
+                    })
+                    break
+
+        elif node.type == "interface_declaration":
+            for child in node.children:
+                if child.type == "identifier":
+                    interface_name = self._get_node_text(child, code)
+                    qualified_name = f"{package}.{interface_name}" if package else interface_name
+                    results.append({
+                        "name": interface_name,
+                        "qualified_name": qualified_name,
+                        "type": "interface",
+                        "line": child.start_point[0] + 1
+                    })
+                    break
+
+        # Recurse into children
+        for child in node.children:
+            self._find_classes_recursive(child, code, package, results)
+
+    def _extract_methods(self, root: Node, code: str, package: str) -> list[dict]:
+        """Extract method declarations by traversing AST."""
+        methods = []
+        self._find_methods_recursive(root, code, package, methods)
+        return methods
+
+    def _find_methods_recursive(self, node: Node, code: str, package: str, results: list):
+        """Recursively find method declarations and constructors."""
+        if node.type == "method_declaration":
+            method_info = self._parse_method_node(node, code, package)
+            if method_info:
+                results.append(method_info)
+        elif node.type == "constructor_declaration":
+            constructor_info = self._parse_constructor_node(node, code, package)
+            if constructor_info:
+                results.append(constructor_info)
+
+        # Recurse into children
+        for child in node.children:
+            self._find_methods_recursive(child, code, package, results)
+
+    def _parse_method_node(self, node: Node, code: str, package: str) -> dict | None:
+        """Parse a method_declaration node."""
+        method_name = None
+        return_type = "void"
+        parameters = []
+
+        for child in node.children:
+            if child.type == "identifier":
+                method_name = self._get_node_text(child, code)
+            elif child.type in ("type_identifier", "void_type", "integral_type",
+                               "floating_point_type", "boolean_type", "generic_type"):
+                return_type = self._get_node_text(child, code)
+            elif child.type == "formal_parameters":
+                parameters = self._parse_parameters(child, code)
+
+        if not method_name:
+            return None
+
+        # Find containing class
+        class_name = self._find_containing_class(node, code)
+        qualified_name = f"{package}.{class_name}.{method_name}" if package else f"{class_name}.{method_name}"
+
+        return {
+            "name": method_name,
+            "qualified_name": qualified_name,
+            "return_type": return_type,
+            "parameters": parameters,
+            "parent_class": class_name,
+            "line": node.start_point[0] + 1
+        }
+
+    def _parse_constructor_node(self, node: Node, code: str, package: str) -> dict | None:
+        """Parse a constructor_declaration node."""
+        constructor_name = None
+        parameters = []
+
+        for child in node.children:
+            if child.type == "identifier":
+                constructor_name = self._get_node_text(child, code)
+            elif child.type == "formal_parameters":
+                parameters = self._parse_parameters(child, code)
+
+        if not constructor_name:
+            return None
+
+        # Find containing class
+        class_name = self._find_containing_class(node, code)
+        qualified_name = f"{package}.{class_name}.{constructor_name}" if package else f"{class_name}.{constructor_name}"
+
+        return {
+            "name": constructor_name,
+            "qualified_name": qualified_name,
+            "return_type": class_name,  # Constructors return instance of the class
+            "parameters": parameters,
+            "parent_class": class_name,
+            "line": node.start_point[0] + 1
+        }
+
+    def _parse_parameters(self, params_node: Node, code: str) -> list[dict]:
+        """Parse formal_parameters node."""
+        parameters = []
+
+        for child in params_node.children:
+            if child.type == "formal_parameter":
+                param_type = None
+                param_name = None
+
+                for part in child.children:
+                    if part.type in ("type_identifier", "integral_type", "generic_type",
+                                   "floating_point_type", "boolean_type"):
+                        param_type = self._get_node_text(part, code)
+                    elif part.type == "identifier":
+                        param_name = self._get_node_text(part, code)
+
+                if param_type and param_name:
+                    parameters.append({
+                        "name": param_name,
+                        "type": param_type
+                    })
+
+        return parameters
+
+    def _extract_imports(self, root: Node, code: str) -> list[dict]:
+        """Extract import statements by traversing AST."""
+        imports = []
+        self._find_imports_recursive(root, code, imports)
+        return imports
+
+    def _find_imports_recursive(self, node: Node, code: str, results: list):
+        """Recursively find import declarations."""
+        if node.type == "import_declaration":
+            for child in node.children:
+                if child.type in ("scoped_identifier", "identifier"):
+                    import_path = self._get_node_text(child, code)
+                    results.append({
+                        "import_path": import_path,
+                        "line": child.start_point[0] + 1,
+                        "is_static": False
+                    })
+                    break
+
+        # Recurse
+        for child in node.children:
+            self._find_imports_recursive(child, code, results)
+
+    def _extract_string_literals(self, root: Node, code: str) -> list[str]:
+        """Extract string literals by traversing AST."""
+        literals = []
+        self._find_string_literals_recursive(root, code, literals)
+        return list(set(literals))
+
+    def _find_string_literals_recursive(self, node: Node, code: str, results: list):
+        """Recursively find string literals."""
+        if node.type == "string_literal":
+            text = self._get_node_text(node, code)
+            # Remove quotes
+            if text.startswith('"') and text.endswith('"'):
+                text = text[1:-1]
+            results.append(text)
+
+        # Recurse
+        for child in node.children:
+            self._find_string_literals_recursive(child, code, results)
+
+    def _extract_method_calls(self, root: Node, code: str) -> list[dict]:
+        """Extract method invocations by traversing AST."""
+        calls = []
+        self._find_method_calls_recursive(root, code, calls)
+        return calls
+
+    def _find_method_calls_recursive(self, node: Node, code: str, results: list):
+        """Recursively find method invocations."""
+        if node.type == "method_invocation":
+            method_name = None
+            object_name = "unknown"
+
+            for child in node.children:
+                if child.type == "identifier":
+                    method_name = self._get_node_text(child, code)
+                elif child.type in ("field_access", "identifier"):
+                    object_name = self._get_node_text(child, code)
+
+            if method_name:
+                results.append({
+                    "object": object_name,
+                    "method": method_name,
+                    "line": node.start_point[0] + 1
+                })
+
+        # Recurse
+        for child in node.children:
+            self._find_method_calls_recursive(child, code, results)
+
+    # Spring annotation names that map to HTTP endpoints
+    _SPRING_ENDPOINT_ANNOTATIONS = {
+        "RequestMapping", "GetMapping", "PostMapping",
+        "PutMapping", "PatchMapping", "DeleteMapping",
+    }
+    _ANNOTATION_HTTP_METHOD = {
+        "GetMapping": "GET", "PostMapping": "POST", "PutMapping": "PUT",
+        "PatchMapping": "PATCH", "DeleteMapping": "DELETE",
+        "RequestMapping": "ANY",
+    }
+
+    def _extract_spring_endpoints(self, root: Node, code: str, package: str) -> list[dict]:
+        """
+        Extract Spring MVC REST endpoints from class and method annotations.
+
+        Strategy:
+        1. Find @RequestMapping on a class  → base_path
+        2. Find @*Mapping on each method    → method_path
+        3. Combine: full_path = base_path + method_path
+        """
+        endpoints: list[dict] = []
+
+        def annotation_name_and_path(annotation_node: Node) -> tuple[str | None, str | None]:
+            name = None
+            path = None
+            for child in annotation_node.children:
+                if child.type == "identifier":
+                    name = self._get_node_text(child, code)
+                elif child.type == "type_identifier":
+                    name = self._get_node_text(child, code)
+                elif child.type == "annotation_argument_list":
+                    # value="..." or ("...") or (value="...")
+                    for arg in child.children:
+                        if arg.type == "string_literal":
+                            raw = self._get_node_text(arg, code).strip('"')
+                            path = raw
+                        elif arg.type == "element_value_pair":
+                            key_node = None
+                            val_node = None
+                            for sub in arg.children:
+                                if sub.type == "identifier":
+                                    key_node = self._get_node_text(sub, code)
+                                elif sub.type == "string_literal":
+                                    val_node = self._get_node_text(sub, code).strip('"')
+                            if key_node in (None, "value", "path") and val_node:
+                                path = val_node
+            return name, path
+
+        def collect_class_endpoints(class_node: Node):
+            base_path = ""
+            class_name = "Unknown"
+
+            # Get class name
+            for child in class_node.children:
+                if child.type == "identifier":
+                    class_name = self._get_node_text(child, code)
+
+            # Scan annotations before the class body
+            for child in class_node.children:
+                if child.type == "modifiers":
+                    for mod in child.children:
+                        if mod.type == "annotation":
+                            aname, apath = annotation_name_and_path(mod)
+                            if aname == "RequestMapping" and apath:
+                                base_path = apath.rstrip("/")
+
+            # Scan method declarations for HTTP mappings
+            qualified_class = f"{package}.{class_name}" if package else class_name
+            for child in class_node.children:
+                if child.type == "class_body":
+                    for body_child in child.children:
+                        if body_child.type == "method_declaration":
+                            method_annotations: list[tuple[str, str]] = []
+                            method_name = None
+
+                            for mc in body_child.children:
+                                if mc.type == "modifiers":
+                                    for mod in mc.children:
+                                        if mod.type == "annotation":
+                                            aname, apath = annotation_name_and_path(mod)
+                                            if aname in self._SPRING_ENDPOINT_ANNOTATIONS:
+                                                method_annotations.append(
+                                                    (aname, apath or "")
+                                                )
+                                elif mc.type == "identifier":
+                                    method_name = self._get_node_text(mc, code)
+
+                            for aname, method_path in method_annotations:
+                                full_path = (base_path + "/" + method_path.lstrip("/")).rstrip("/")
+                                if not full_path.startswith("/"):
+                                    full_path = "/" + full_path
+                                http_method = self._ANNOTATION_HTTP_METHOD.get(aname, "ANY")
+                                endpoints.append({
+                                    "path": full_path,
+                                    "http_method": http_method,
+                                    "class_name": qualified_class,
+                                    "method_name": method_name or "",
+                                    "line": body_child.start_point[0] + 1,
+                                })
+
+        def traverse(node: Node):
+            if node.type == "class_declaration":
+                collect_class_endpoints(node)
+            for child in node.children:
+                traverse(child)
+
+        traverse(root)
+        return endpoints
+
+    def _find_containing_class(self, node: Node, code: str) -> str:
+        """Find the class that contains the given node by walking up the tree."""
+        current = node.parent
+
+        while current:
+            if current.type in ("class_declaration", "interface_declaration"):
+                for child in current.children:
+                    if child.type == "identifier":
+                        return self._get_node_text(child, code)
+            current = current.parent
+
+        return "Unknown"
+
+    def _get_node_text(self, node: Node, code: str) -> str:
+        """Get text content of a tree-sitter node."""
+        return code[node.start_byte:node.end_byte]