adl-toolkit 0.0.0-stage → 0.1.1

package/adl_drift/lang/java/detectors/data_access.py

@@ -0,0 +1,148 @@
+"""JDBC, JPA/Hibernate, Spring Data, and MyBatis detector."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List, Optional, Set
+
+from tree_sitter import Node, Tree
+
+from adl_drift.lang.java.detectors.base import DeclaredTypes, JavaDetector
+from adl_drift.lang.java.scopes import TypeScopes
+from adl_drift.utils.types import Pattern, PatternCategory
+
+JDBC_TYPES = {"Statement", "PreparedStatement", "CallableStatement", "Connection"}
+JDBC_STATEMENT_TYPES = {"Statement", "PreparedStatement", "CallableStatement"}
+JPA_METHODS = {"createQuery", "createNativeQuery", "persist", "merge", "remove", "find", "save"}
+MYBATIS_METHODS = {"selectOne", "selectList", "insert", "update", "delete"}
+PERSISTENCE_PACKAGES = ("jakarta.persistence", "javax.persistence")
+MYBATIS_PACKAGE = "org.apache.ibatis.annotations"
+MYBATIS_SESSION_TYPES = {
+    "SqlSession": "org.apache.ibatis.session.SqlSession",
+    "SqlSessionTemplate": "org.mybatis.spring.SqlSessionTemplate",
+}
+JDBC_TYPE_NAMES = {name: f"java.sql.{name}" for name in JDBC_TYPES}
+JPA_TYPE_NAMES = {
+    "EntityManager": ("jakarta.persistence.EntityManager", "javax.persistence.EntityManager"),
+    "Session": ("org.hibernate.Session",),
+    "StatelessSession": ("org.hibernate.StatelessSession",),
+}
+
+
+class JavaDataAccessDetector(JavaDetector):
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.DATA_ACCESS
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        root = tree.root_node
+        imports = self._imports(root, source_bytes)
+        types = self._declared_types(root, source_bytes)
+        local_types = self._declared_type_names(root, source_bytes)
+        patterns: List[Pattern] = []
+        for node in self._walk(root):
+            if node.type == "method_invocation":
+                pattern = self._call(
+                    node, source_bytes, file_path, types, imports, local_types
+                )
+                if pattern:
+                    patterns.append(pattern)
+            elif node.type in ("class_declaration", "interface_declaration"):
+                patterns.extend(self._declaration(node, source_bytes, file_path, imports))
+            elif node.type == "method_declaration":
+                pattern = self._mybatis_annotation(node, source_bytes, file_path, imports)
+                if pattern:
+                    patterns.append(pattern)
+        return patterns
+
+    def _call(
+        self, node: Node, source: bytes, path: Path,
+        types: DeclaredTypes, imports: Set[str], local_types: TypeScopes,
+    ) -> Optional[Pattern]:
+        method = self._text(node.child_by_field_name("name"), source)
+        receiver = self._text(node.child_by_field_name("object"), source)
+        raw_declared = self._declared_type(receiver, types, node)
+        declared = self._simple_type(raw_declared)
+        jdbc_type = JDBC_TYPE_NAMES.get(declared)
+        jdbc_method = (
+            declared in JDBC_STATEMENT_TYPES and method.startswith("execute")
+        ) or (declared == "Connection" and method == "prepareStatement")
+        if jdbc_type and jdbc_method and self._type_has_provenance(
+            raw_declared, imports, local_types, jdbc_type, node
+        ):
+            return self._finding("jdbc_operation", "jdbc", method, node, path, 0.95,
+                                 "JDBC receiver type and operation match")
+        jpa_type_names = JPA_TYPE_NAMES.get(declared, ())
+        if method in JPA_METHODS and any(
+            self._type_has_provenance(raw_declared, imports, local_types, qualified, node)
+            for qualified in jpa_type_names
+        ):
+            return self._finding("jpa_operation", "jpa", method, node, path, 0.93,
+                                 "JPA/Hibernate receiver type and operation match")
+        mybatis_type = MYBATIS_SESSION_TYPES.get(declared)
+        if mybatis_type and method in MYBATIS_METHODS and self._type_has_provenance(
+            raw_declared, imports, local_types, mybatis_type, node
+        ):
+            return self._finding("mybatis_operation", "mybatis", method, node, path, 0.93,
+                                 "MyBatis session receiver type and operation match")
+        return None
+
+    def _declaration(
+        self, node: Node, source: bytes, path: Path, imports: Set[str]
+    ) -> List[Pattern]:
+        patterns: List[Pattern] = []
+        for annotation in self._annotations(node):
+            if any(self._annotation_is(annotation, source, imports, f"{p}.Entity")
+                   for p in PERSISTENCE_PACKAGES):
+                patterns.append(self._finding(
+                    "jpa_entity", "jpa", "entity", node, path, 0.98,
+                    "Class is annotated with the imported JPA @Entity annotation",
+                ))
+            if self._annotation_is(annotation, source, imports, f"{MYBATIS_PACKAGE}.Mapper"):
+                patterns.append(self._finding(
+                    "mybatis_mapper", "mybatis", "mapper", node, path, 0.98,
+                    "Type is annotated with MyBatis @Mapper",
+                ))
+
+        repository_types = {
+            "JpaRepository": "org.springframework.data.jpa.repository.JpaRepository",
+            "CrudRepository": "org.springframework.data.repository.CrudRepository",
+            "PagingAndSortingRepository": "org.springframework.data.repository.PagingAndSortingRepository",
+        }
+        if node.type == "interface_declaration" and any(
+            f"{marker}<" in self._text(node, source)
+            and self._has_import(imports, qualified)
+            for marker, qualified in repository_types.items()
+        ):
+            patterns.append(self._finding(
+                "spring_data_repository", "spring-data", "repository", node, path, 0.96,
+                "Interface extends a Spring Data repository contract",
+            ))
+        return patterns
+
+    def _mybatis_annotation(
+        self, node: Node, source: bytes, path: Path, imports: Set[str]
+    ) -> Optional[Pattern]:
+        for annotation in self._annotations(node):
+            name = self._annotation_name(annotation, source).rsplit(".", 1)[-1]
+            if name in {"Select", "Insert", "Update", "Delete"} and self._annotation_is(
+                annotation, source, imports, f"{MYBATIS_PACKAGE}.{name}"
+            ):
+                return self._finding(
+                    "mybatis_statement", "mybatis", name.lower(), node, path, 0.98,
+                    f"Method uses imported MyBatis @{name} SQL annotation",
+                )
+        return None
+
+    def _finding(
+        self, name: str, framework: str, operation: str, node: Node,
+        path: Path, confidence: float, reason: str,
+    ) -> Pattern:
+        return self._make_pattern(
+            name=name,
+            description=f"{framework} data access: {operation}",
+            node=node,
+            file_path=path,
+            confidence=confidence,
+            metadata={"framework": framework, "operation": operation, "reason": reason},
+        )

package/adl_drift/lang/java/detectors/imports.py

@@ -0,0 +1,53 @@
+"""Java import classification detector."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import List
+
+from tree_sitter import Tree
+
+from adl_drift.lang.java.detectors.base import JavaDetector
+from adl_drift.utils.types import Pattern, PatternCategory
+
+IMPORT_RE = re.compile(r"import\s+(static\s+)?([\w.]+)(\.\*)?\s*;")
+
+
+class JavaImportDetector(JavaDetector):
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.IMPORTS
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        patterns: List[Pattern] = []
+        for node in tree.root_node.named_children:
+            if node.type != "import_declaration":
+                continue
+            match = IMPORT_RE.fullmatch(self._text(node, source_bytes))
+            if not match:
+                continue
+            is_static = bool(match.group(1))
+            module = match.group(2)
+            is_wildcard = bool(match.group(3))
+            import_type = "jdk" if module.startswith(("java.", "javax.", "jakarta.")) else "third_party"
+            reason = (
+                "Import belongs to the JDK/Jakarta namespace"
+                if import_type == "jdk"
+                else "Import is outside the JDK/Jakarta namespace"
+            )
+            patterns.append(self._make_pattern(
+                name="wildcard_import" if is_wildcard else f"import:{import_type}",
+                description=f"Java {import_type} import: {module}",
+                node=node,
+                file_path=file_path,
+                confidence=0.99,
+                metadata={
+                    "import_type": import_type,
+                    "module": module,
+                    "is_static": is_static,
+                    "is_wildcard": is_wildcard,
+                    "reason": reason,
+                },
+            ))
+        return patterns

package/adl_drift/lang/java/detectors/routes.py

@@ -0,0 +1,159 @@
+"""Spring MVC and JAX-RS route detector."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import List, Optional, Set, Tuple
+
+from tree_sitter import Node, Tree
+
+from adl_drift.lang.java.detectors.base import JavaDetector
+from adl_drift.lang.java.extractor import JavaSymbolExtractor
+from adl_drift.utils.types import Pattern, PatternCategory
+
+SPRING_PACKAGE = "org.springframework.web.bind.annotation"
+JAX_PACKAGES = ("jakarta.ws.rs", "javax.ws.rs")
+SPRING_METHODS = {
+    "GetMapping": "GET",
+    "PostMapping": "POST",
+    "PutMapping": "PUT",
+    "PatchMapping": "PATCH",
+    "DeleteMapping": "DELETE",
+}
+JAX_METHODS = {name: name for name in ("GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS")}
+
+
+class JavaRouteDetector(JavaDetector):
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.ROUTES
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        root = tree.root_node
+        imports = self._imports(root, source_bytes)
+        extractor = JavaSymbolExtractor(self.parser)
+        anon_index = extractor._index_anonymous_classes(root)
+        patterns: List[Pattern] = []
+
+        for method in self._walk(root):
+            if method.type != "method_declaration":
+                continue
+            owner = self._enclosing_class(method)
+            class_annotations = self._annotations(owner) if owner is not None else []
+            method_annotations = self._annotations(method)
+
+            routes = self._spring_routes(
+                class_annotations, method_annotations, source_bytes, imports
+            )
+            if not routes:
+                jax_route = self._jax_route(
+                    class_annotations, method_annotations, source_bytes, imports
+                )
+                routes = [jax_route] if jax_route is not None else []
+            if not routes:
+                continue
+
+            method_symbol = extractor._extract_method(
+                method, source_bytes, file_path, anon_index
+            )
+            if method_symbol is None:
+                continue
+            handler_id = self._handler_id(
+                self._package(root, source_bytes), method_symbol.scope_chain,
+                method_symbol.name, method_symbol.signature_key or "()",
+            )
+            for framework, http_method, class_path, method_path in routes:
+                route_path = self._join_paths(class_path, method_path)
+                reason = f"{framework} route annotation on method {method_symbol.name}"
+                patterns.append(self._make_pattern(
+                    name=f"route:{http_method}",
+                    description=f"{framework} {http_method} route: {route_path}",
+                    node=method,
+                    file_path=file_path,
+                    confidence=0.98,
+                    metadata={
+                        "framework": framework,
+                        "http_method": http_method,
+                        "route_path": route_path,
+                        "class_path": class_path,
+                        "method_path": method_path,
+                        "handler": method_symbol.name,
+                        "handler_id": handler_id,
+                        "entry_point": True,
+                        "reason": reason,
+                    },
+                ))
+        return patterns
+
+    def _spring_routes(
+        self, class_annotations: List[Node], method_annotations: List[Node],
+        source: bytes, imports: Set[str],
+    ) -> List[Tuple[str, str, str, str]]:
+        class_path = ""
+        for annotation in class_annotations:
+            if self._annotation_is(annotation, source, imports, f"{SPRING_PACKAGE}.RequestMapping"):
+                class_path = self._path(annotation, source)
+
+        for annotation in method_annotations:
+            name = self._annotation_name(annotation, source).rsplit(".", 1)[-1]
+            if name in SPRING_METHODS and self._annotation_is(
+                annotation, source, imports, f"{SPRING_PACKAGE}.{name}"
+            ):
+                return [("spring", SPRING_METHODS[name], class_path, self._path(annotation, source))]
+            if name == "RequestMapping" and self._annotation_is(
+                annotation, source, imports, f"{SPRING_PACKAGE}.RequestMapping"
+            ):
+                methods = re.findall(
+                    r"RequestMethod\.(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS)",
+                    self._text(annotation, source),
+                )
+                return [
+                    ("spring", method, class_path, self._path(annotation, source))
+                    for method in methods or ["ANY"]
+                ]
+        return []
+
+    def _jax_route(
+        self, class_annotations: List[Node], method_annotations: List[Node],
+        source: bytes, imports: Set[str],
+    ) -> Optional[Tuple[str, str, str, str]]:
+        class_path = self._jax_path(class_annotations, source, imports)
+        method_path = self._jax_path(method_annotations, source, imports)
+        for annotation in method_annotations:
+            name = self._annotation_name(annotation, source).rsplit(".", 1)[-1]
+            for package in JAX_PACKAGES:
+                if name in JAX_METHODS and self._annotation_is(
+                    annotation, source, imports, f"{package}.{name}"
+                ):
+                    return "jax-rs", JAX_METHODS[name], class_path, method_path
+        return None
+
+    def _jax_path(self, annotations: List[Node], source: bytes, imports: Set[str]) -> str:
+        for annotation in annotations:
+            if any(self._annotation_is(annotation, source, imports, f"{p}.Path") for p in JAX_PACKAGES):
+                return self._path(annotation, source)
+        return ""
+
+    def _path(self, annotation: Node, source: bytes) -> str:
+        strings = self._annotation_strings(annotation, source)
+        return strings[0] if strings else ""
+
+    @staticmethod
+    def _enclosing_class(node: Node) -> Optional[Node]:
+        parent = node.parent
+        while parent is not None and parent.type not in (
+            "class_declaration", "interface_declaration", "record_declaration"
+        ):
+            parent = parent.parent
+        return parent
+
+    @staticmethod
+    def _join_paths(class_path: str, method_path: str) -> str:
+        parts = [part.strip("/") for part in (class_path, method_path) if part.strip("/")]
+        return "/" + "/".join(parts) if parts else "/"
+
+    @staticmethod
+    def _handler_id(package: str, scope: List[str], name: str, signature: str) -> str:
+        qualified = ".".join([*scope, f"{name}{signature}"])
+        return f"{package}:{qualified}"