adl-toolkit 0.0.0-stage → 0.1.1

package/adl_drift/detectors/tests.py

@@ -0,0 +1,95 @@
+"""Test framework detector — pytest + unittest."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from tree_sitter import Node, Tree
+
+from adl_drift.detectors.base import BaseDetector
+from adl_drift.utils.types import Pattern, PatternCategory
+
+
+class TestDetector(BaseDetector):
+    """Flags test functions, fixtures, and unittest.TestCase classes."""
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.TESTS
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        patterns: List[Pattern] = []
+        in_test_file = self._is_test_file(file_path)
+
+        for node in self._walk(tree.root_node):
+            if node.type == "function_definition":
+                name = self._name(node, source_bytes)
+                if not name:
+                    continue
+                decorators = self._decorators(node, source_bytes)
+
+                if any("fixture" in d for d in decorators):
+                    patterns.append(self._make_pattern(
+                        name="pytest_fixture",
+                        description=f"pytest fixture: {name}",
+                        node=node, file_path=file_path, confidence=0.95,
+                        metadata={"framework": "pytest", "function": name},
+                    ))
+                elif name.startswith("test_") and in_test_file:
+                    patterns.append(self._make_pattern(
+                        name="pytest_test",
+                        description=f"pytest test function: {name}",
+                        node=node, file_path=file_path, confidence=0.9,
+                        metadata={"framework": "pytest", "function": name},
+                    ))
+            elif node.type == "class_definition":
+                bases = self._superclass_text(node, source_bytes)
+                if any("TestCase" in b for b in bases):
+                    name = self._name(node, source_bytes) or "<anon>"
+                    patterns.append(self._make_pattern(
+                        name="unittest_testcase",
+                        description=f"unittest.TestCase class: {name}",
+                        node=node, file_path=file_path, confidence=0.95,
+                        metadata={"framework": "unittest", "class": name,
+                                  "bases": bases},
+                    ))
+        return patterns
+
+    def _name(self, node: Node, source: bytes):
+        nn = node.child_by_field_name("name")
+        return self.parser.node_text(nn, source) if nn else None
+
+    def _decorators(self, node: Node, source: bytes) -> List[str]:
+        out: List[str] = []
+        sib = node.prev_sibling
+        while sib and sib.type == "decorator":
+            out.append(self.parser.node_text(sib, source).strip())
+            sib = sib.prev_sibling
+        if node.parent and node.parent.type == "decorated_definition":
+            for c in node.parent.children:
+                if c.type == "decorator":
+                    txt = self.parser.node_text(c, source).strip()
+                    if txt not in out:
+                        out.append(txt)
+        return out
+
+    def _superclass_text(self, node: Node, source: bytes) -> List[str]:
+        sc = node.child_by_field_name("superclasses")
+        if not sc:
+            return []
+        out: List[str] = []
+        for c in sc.children:
+            if c.type in ("identifier", "attribute"):
+                out.append(self.parser.node_text(c, source).strip())
+        return out
+
+    @staticmethod
+    def _is_test_file(file_path: Path) -> bool:
+        n = file_path.name
+        return n.startswith("test_") or n.endswith("_test.py") or "tests" in file_path.parts
+
+    def _walk(self, node: Node):
+        yield node
+        for child in node.children:
+            yield from self._walk(child)

package/adl_drift/detectors/type_conventions.py

@@ -0,0 +1,81 @@
+"""Type-annotation coverage detector.
+
+Per-file pattern: ratio of annotated params/returns. One Pattern per scanned
+file with coverage % in metadata. Depends on P1.3 (Symbol.param_types /
+return_type populated).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+from tree_sitter import Node, Tree
+
+from adl_drift.detectors.base import BaseDetector
+from adl_drift.utils.types import Pattern, PatternCategory
+
+
+class TypeConventionDetector(BaseDetector):
+    """Computes type-annotation coverage for a file."""
+
+    @property
+    def category(self) -> PatternCategory:
+        return PatternCategory.TYPES
+
+    def detect(self, tree: Tree, source_bytes: bytes, file_path: Path) -> List[Pattern]:
+        total_params = 0
+        typed_params = 0
+        total_funcs = 0
+        typed_returns = 0
+
+        for node in self._walk(tree.root_node):
+            if node.type != "function_definition":
+                continue
+            total_funcs += 1
+            params_node = node.child_by_field_name("parameters")
+            if params_node is not None:
+                for child in params_node.children:
+                    ct = child.type
+                    if ct == "identifier":
+                        text = self.parser.node_text(child, source_bytes)
+                        if text in ("self", "cls"):
+                            continue
+                        total_params += 1
+                    elif ct == "default_parameter":
+                        total_params += 1
+                    elif ct in ("typed_parameter", "typed_default_parameter"):
+                        total_params += 1
+                        typed_params += 1
+            if node.child_by_field_name("return_type") is not None:
+                typed_returns += 1
+
+        if total_funcs == 0:
+            return []
+
+        param_cov = typed_params / total_params if total_params else 1.0
+        return_cov = typed_returns / total_funcs
+
+        return [self._make_pattern(
+            name="type_coverage",
+            description=(
+                f"type coverage — params {typed_params}/{total_params} "
+                f"({param_cov:.0%}), returns {typed_returns}/{total_funcs} "
+                f"({return_cov:.0%})"
+            ),
+            node=tree.root_node, file_path=file_path,
+            confidence=0.95,
+            metadata={
+                "total_params": total_params,
+                "typed_params": typed_params,
+                "param_coverage": round(param_cov, 3),
+                "total_functions": total_funcs,
+                "typed_returns": typed_returns,
+                "return_coverage": round(return_cov, 3),
+            },
+        )]
+
+    def _walk(self, node: Node):
+        yield node
+        for child in node.children:
+            yield from self._walk(child)

package/adl_drift/graph/__init__.py

@@ -0,0 +1 @@
+"""Call graph and dependency analysis."""