codd-dev 3.7.2__tar.gz → 3.7.4__tar.gz

{codd_dev-3.7.2 → codd_dev-3.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 3.7.2
+Version: 3.7.4
 Summary: CoDD: Coherence-Driven Development — cross-artifact change impact analysis
 Project-URL: Homepage, https://github.com/yohey-w/codd-dev
 Project-URL: Repository, https://github.com/yohey-w/codd-dev

{codd_dev-3.7.2 → codd_dev-3.7.4}/codd/__init__.py

@@ -1,3 +1,3 @@
 """CoDD — Coherence-Driven Development."""
 
-__version__ = "3.7.2"
+__version__ = "3.7.4"

{codd_dev-3.7.2 → codd_dev-3.7.4}/codd/dag/builder.py

@@ -10,7 +10,7 @@ import warnings
 from copy import deepcopy
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 import yaml
 
@@ -911,6 +911,32 @@ def _resolve_import_target(
     path_to_node: dict[Path, str],
     aliases: dict[str, list[str]],
 ) -> str | None:
+    # Java FQN specifiers (``com.x.Y`` / ``static com.x.Y.m`` / ``com.x.*`` /
+    # ``package com.x``) are dispatched by the IMPORTING file's ``.java`` suffix
+    # (DATA, not a ``language ==`` core branch) because their dotted shape
+    # otherwise collides with Python's project-rooted dotted resolution. Java
+    # types live under a source root (``src/main/java``), not the project root.
+    if file_path.suffix == ".java":
+        candidates = _java_import_candidates(import_ref, file_path, project_root, path_to_node)
+        for candidate in candidates:
+            resolved = _resolve_file_candidate(candidate, path_to_node)
+            if resolved:
+                return resolved
+        return None
+
+    # C++ ``#include`` specifiers are dispatched by the IMPORTING file's C/C++
+    # suffix (DATA, not a ``language ==`` core branch). Resolution is PATH-based
+    # (the specifier already carries its extension, e.g. ``fmt/core.h``), the key
+    # divergence from Java's FQN→path synthesis: a quote-form include resolves
+    # relative-to-file first, then via include roots; an angle-form include is
+    # system/STL and produces no edge.
+    if file_path.suffix in _CPP_SOURCE_SUFFIXES:
+        for candidate in _cpp_include_candidates(import_ref, file_path, path_to_node):
+            resolved = _resolve_file_candidate(candidate, path_to_node)
+            if resolved:
+                return resolved
+        return None
+
     candidates: list[Path] = []
     if _is_js_relative_specifier(import_ref):
         # JS/TS relative: ``./foo`` / ``../foo`` — resolve against the file dir
@@ -981,6 +1007,218 @@ def _python_relative_candidates(import_ref: str, file_path: Path) -> list[Path]:
     return [(base / Path(*remainder.split("."))).resolve()]
 
 
+#: Conventional Java/JVM source-root segment chains (Maven/Gradle). A type whose
+#: FQN is ``com.x.Y`` lives at ``<root>/com/x/Y.java`` under one of these roots.
+_JAVA_SOURCE_ROOT_SEGMENTS = (
+    ("src", "main", "java"),
+    ("src", "test", "java"),
+    ("src", "main", "kotlin"),
+    ("src", "test", "kotlin"),
+)
+
+
+def _java_source_roots(project_root: Path, path_to_node: dict[Path, str]) -> list[Path]:
+    """Return candidate Java source roots (deepest-first), derived from DATA.
+
+    Built from the actual node file-set rather than hard-coded paths: every
+    ``…/src/main/java`` (etc.) prefix that some node file sits under becomes a
+    root, plus the project root itself as a last resort (flat layouts / default
+    package). Deeper roots are tried first so ``src/main/java`` wins over the
+    project root when both could match.
+    """
+    roots: dict[str, Path] = {}
+    for file_path in path_to_node:
+        parts = file_path.parts
+        for segments in _JAVA_SOURCE_ROOT_SEGMENTS:
+            idx = _find_segment_chain(parts, segments)
+            if idx is not None:
+                root = Path(*parts[: idx + len(segments)])
+                roots[str(root)] = root
+    ordered = sorted(roots.values(), key=lambda path: len(path.parts), reverse=True)
+    ordered.append(project_root.resolve())
+    return ordered
+
+
+def _find_segment_chain(parts: tuple[str, ...], chain: tuple[str, ...]) -> int | None:
+    """Return the start index where ``chain`` appears contiguously in ``parts``."""
+    if not chain:
+        return None
+    for start in range(len(parts) - len(chain) + 1):
+        if parts[start : start + len(chain)] == chain:
+            return start
+    return None
+
+
+def _java_import_candidates(
+    import_ref: str,
+    file_path: Path,
+    project_root: Path,
+    path_to_node: dict[Path, str],
+) -> list[Path]:
+    """Map a Java specifier to filesystem candidates under the source roots.
+
+    Handles the four shapes emitted by the Java specifier extractor:
+
+    * ``package com.x`` → the file's OWN package dir, so same-package implicit
+      references (Java needs no import for siblings) yield edges to the package's
+      other files (the caller skips the self-edge).
+    * ``com.x.*`` (wildcard) → the package directory; the caller links to the
+      in-package files found there (or skips cleanly when none are nodes).
+    * ``static com.x.Y.m`` → the owning class file ``com/x/Y.java`` (member
+      ``m`` stripped).
+    * ``com.x.Y`` (normal) → ``com/x/Y.java``.
+
+    ``_resolve_file_candidate`` appends the real ``.java`` suffix once a directory
+    candidate is produced, so package/wildcard dirs resolve to a sibling file.
+    """
+    roots = _java_source_roots(project_root, path_to_node)
+
+    if import_ref.startswith("package "):
+        package = import_ref[len("package "):].strip()
+        return _java_package_dir_candidates(package, roots)
+
+    if import_ref.endswith(".*"):
+        package = import_ref[:-2].strip()
+        return _java_package_dir_candidates(package, roots)
+
+    fqn = import_ref
+    if fqn.startswith("static "):
+        # ``static com.x.Y.member`` → owning class ``com.x.Y`` (drop the member).
+        fqn = fqn[len("static "):].strip()
+        parts = fqn.split(".")
+        if len(parts) >= 2:
+            fqn = ".".join(parts[:-1])
+
+    parts = [part for part in fqn.split(".") if part]
+    if not parts:
+        return []
+    return [(root / Path(*parts)).resolve() for root in roots]
+
+
+def _java_package_dir_candidates(package: str, roots: list[Path]) -> list[Path]:
+    parts = [part for part in package.split(".") if part]
+    if not parts:
+        return []
+    candidates: list[Path] = []
+    for root in roots:
+        package_dir = (root / Path(*parts)).resolve()
+        # List the package dir's in-tree files as candidates (same-package /
+        # wildcard linkage). ``_resolve_file_candidate`` matches exact node paths,
+        # so we hand it each existing ``.java`` file directly.
+        for node_path in _sorted_java_dir_files(package_dir):
+            candidates.append(node_path)
+    return candidates
+
+
+def _sorted_java_dir_files(package_dir: Path) -> list[Path]:
+    if not package_dir.is_dir():
+        return []
+    return sorted(
+        child.resolve()
+        for child in package_dir.iterdir()
+        if child.is_file() and child.suffix == ".java"
+    )
+
+
+#: C/C++ source/header suffixes whose ``#include`` directives carry the intra-tree
+#: dependency graph. Used to suffix-dispatch the PATH-based resolver branch (DATA,
+#: not a ``language ==`` core gate). Kept in sync with the ``.h``/``.cc``/… keys of
+#: ``_SUFFIX_SPECIFIER_EXTRACTORS``.
+_CPP_SOURCE_SUFFIXES = frozenset({".h", ".hpp", ".hh", ".cc", ".cpp", ".cxx"})
+
+#: Conventional C/C++ include-root directory names. A quote-form include such as
+#: ``"fmt/core.h"`` that is not relative to the including file is probed under
+#: these roots (``include`` covers fmt's ``include/fmt/*.h`` layout). Harvested
+#: header-node parent dirs are added at resolution time so unconventional roots
+#: still resolve from DATA.
+_CPP_INCLUDE_ROOTS = ("include", "src", "inc")
+
+
+def _cpp_include_candidates(
+    import_ref: str,
+    file_path: Path,
+    path_to_node: dict[Path, str],
+) -> list[Path]:
+    """Map a C++ ``#include`` specifier to filesystem candidates (PATH-based).
+
+    The specifier is marker-prefixed by ``_extract_cpp_include_specifiers``:
+
+    * ``angle:vector`` (``#include <vector>``) → system/STL: NO candidates, so no
+      edge forms (mirrors Java ``java.*`` producing no edge).
+    * ``quote:fmt/core.h`` (``#include "fmt/core.h"``) → local header. The path
+      ALREADY has its extension, so there is NO suffix synthesis (the divergence
+      from Java's FQN→path mapping). Resolution order:
+        1. relative to the including file's directory (``file.parent / spec``);
+        2. each conventional include root (``include``/``src``/``inc``) under the
+           project tree, located by walking up from the including file;
+        3. the parent directory of every header node already in the file-set
+           (harvested from DATA), so unconventional include roots still resolve.
+
+    ``_resolve_file_candidate`` matches exact node paths first, so a fully-pathed
+    candidate (``…/include/fmt/core.h``) resolves directly to its node.
+    """
+    if import_ref.startswith(_CPP_ANGLE_SPECIFIER):
+        return []
+    if import_ref.startswith(_CPP_QUOTE_SPECIFIER):
+        spec = import_ref[len(_CPP_QUOTE_SPECIFIER):]
+    else:
+        # Defensive: an unmarked specifier (e.g. a future extractor) is treated
+        # as a quote-form local include.
+        spec = import_ref
+    spec = spec.strip()
+    if not spec:
+        return []
+
+    rel = Path(spec)
+    candidates: list[Path] = []
+    # 1. Relative to the including file's own directory (quote-form's primary
+    #    rule — ``#include "lib/b.h"`` next to ``a.cc``).
+    candidates.append((file_path.parent / rel).resolve())
+
+    # 2. Conventional include roots discovered by walking up the including file's
+    #    ancestors (so ``include/fmt/core.h`` resolves from ``src/format.cc``).
+    seen: set[Path] = set()
+    for ancestor in [file_path.parent, *file_path.parents]:
+        for root_name in _CPP_INCLUDE_ROOTS:
+            root = ancestor / root_name
+            key = root.resolve()
+            if key in seen:
+                continue
+            seen.add(key)
+            candidates.append((root / rel).resolve())
+
+    # 3. Harvest header-node parent directories from the file-set (DATA), so an
+    #    unconventional include root still resolves the trailing path segment(s).
+    for header_dir in _cpp_header_root_dirs(path_to_node):
+        candidates.append((header_dir / rel).resolve())
+
+    return candidates
+
+
+def _cpp_header_root_dirs(path_to_node: dict[Path, str]) -> list[Path]:
+    """Candidate include roots harvested from header nodes in the file-set.
+
+    For a header node ``…/include/fmt/core.h`` whose include path is ``fmt/core.h``
+    the include ROOT is ``…/include``. We cannot know the split a priori, so we
+    offer each header's parent AND grandparent dirs as roots; the joined
+    candidate only resolves when it matches a real node path, so over-offering is
+    harmless (no false edges).
+    """
+    roots: dict[str, Path] = {}
+    for node_path in path_to_node:
+        if node_path.suffix not in _CPP_HEADER_SUFFIXES:
+            continue
+        for ancestor in (node_path.parent, node_path.parent.parent):
+            resolved = ancestor.resolve()
+            roots[str(resolved)] = resolved
+    return sorted(roots.values(), key=lambda path: len(path.parts), reverse=True)
+
+
+#: C/C++ header suffixes (subset of ``_CPP_SOURCE_SUFFIXES``) used to harvest
+#: include-root directories from the node file-set.
+_CPP_HEADER_SUFFIXES = frozenset({".h", ".hpp", ".hh"})
+
+
 def _infer_test_targets(
     test_path: Path,
     project_root: Path,
@@ -1025,30 +1263,134 @@ def _extract_python_import_specifiers(file_path: Path) -> list[str]:
     return get_extractor("python", "source").extract_import_specifiers(content)
 
 
+# Regex fallback for Java ``import`` / ``package`` specifiers, used only when the
+# tree-sitter-java binding is unavailable (otherwise the registry backend's AST
+# extractor is preferred). Mirrors the SHAPES emitted by
+# ``treesitter._extract_java_import_specifiers`` (``static`` keyword + ``.*``
+# wildcard + ``package`` line preserved) so the Java resolver branch is agnostic
+# to which extractor produced the specifier.
+_JAVA_IMPORT_SPECIFIER_RE = re.compile(
+    r"^\s*import\s+(static\s+)?([\w.]+(?:\.\*)?)\s*;",
+    re.MULTILINE,
+)
+_JAVA_PACKAGE_SPECIFIER_RE = re.compile(r"^\s*package\s+([\w.]+)\s*;", re.MULTILINE)
+
+
+def _extract_java_import_specifiers(file_path: Path) -> list[str]:
+    """Return raw Java ``import``/``package`` specifiers for DAG edge building.
+
+    Prefers the registry's Java ``source`` backend (tree-sitter-java) so the SAME
+    extraction the scanner uses produces the DAG specifiers; degrades to a regex
+    when the binding is absent. Either way the SHAPES (``static …`` / ``….*`` /
+    ``package …``) match, so ``_resolve_import_target``'s Java branch — dispatched
+    by the ``.java`` suffix (DATA), not a ``language ==`` core branch — resolves
+    them identically. Mirrors ``_extract_python_import_specifiers``.
+    """
+
+    from codd.parsing import get_extractor
+
+    content = file_path.read_text(encoding="utf-8", errors="ignore")
+    specifiers = get_extractor("java", "source").extract_import_specifiers(content)
+    if specifiers:
+        return specifiers
+    # Fallback: tree-sitter-java unavailable → RegexExtractor returned []. Recover
+    # the same specifier shapes from a line regex so Java edges still form.
+    fallback: list[str] = []
+    package_match = _JAVA_PACKAGE_SPECIFIER_RE.search(content)
+    if package_match:
+        fallback.append(f"package {package_match.group(1)}")
+    for static_kw, name in _JAVA_IMPORT_SPECIFIER_RE.findall(content):
+        if name.endswith(".*"):
+            fallback.append(name)
+        elif static_kw:
+            fallback.append(f"static {name}")
+        else:
+            fallback.append(name)
+    return fallback
+
+
+# C++ ``#include`` directives. The DAG resolver needs to know quote-form
+# (``"…"`` — local, relative-first) vs angle-form (``<…>`` — system/STL, no
+# edge), so the extractor preserves that distinction by prefixing a marker:
+#   ``"fmt/core.h"`` → ``quote:fmt/core.h``
+#   ``<vector>``     → ``angle:vector``
+# Built-in regex (NOT routed through the registry): tree-sitter-cpp is not
+# installed, and ``RegexExtractor.extract_import_specifiers`` returns ``[]`` for
+# C++, so a self-contained regex is the source of these specifiers. The marker
+# is stripped by the resolver's ``.suffix``-dispatched C++ branch.
+_CPP_QUOTE_SPECIFIER = "quote:"
+_CPP_ANGLE_SPECIFIER = "angle:"
+_CPP_INCLUDE_RE = re.compile(
+    r'^\s*#\s*include\s*(?:"([^"]+)"|<([^>]+)>)',
+    re.MULTILINE,
+)
+
+
+def _extract_cpp_include_specifiers(file_path: Path) -> list[str]:
+    """Return raw C++ ``#include`` specifiers (quote/angle-marked) for the DAG.
+
+    Mirrors ``_extract_java_import_specifiers`` in role (suffix-dispatched raw
+    specifier extraction) but uses a built-in regex because tree-sitter-cpp is
+    absent. The quote/angle form is carried as a marker prefix so the
+    PATH-based resolver can apply the right rule: quote-form resolves
+    relative-to-file then via include roots; angle-form is system/STL and forms
+    no edge (analogous to Java ``java.*`` producing no edge).
+    """
+
+    content = file_path.read_text(encoding="utf-8", errors="ignore")
+    specifiers: list[str] = []
+    for quote_target, angle_target in _CPP_INCLUDE_RE.findall(content):
+        if quote_target:
+            specifiers.append(f"{_CPP_QUOTE_SPECIFIER}{quote_target}")
+        elif angle_target:
+            specifiers.append(f"{_CPP_ANGLE_SPECIFIER}{angle_target}")
+    return specifiers
+
+
+#: Suffix → raw-specifier extractor (DATA dispatch). A source file whose language
+#: carries its intra-tree dependency graph in DOTTED specifiers (Python modules,
+#: Java FQNs) or ``#include`` directives (C/C++) resolves edges from these,
+#: instead of the builder's quoted-string ``extract_imports`` seam (JS/TS
+#: ``from '…'`` / ``require('…')``). Adding a language here is pure data — no
+#: core ``if language ==`` branch.
+_SUFFIX_SPECIFIER_EXTRACTORS: dict[str, "Callable[[Path], list[str]]"] = {
+    ".py": _extract_python_import_specifiers,
+    ".java": _extract_java_import_specifiers,
+    ".h": _extract_cpp_include_specifiers,
+    ".hpp": _extract_cpp_include_specifiers,
+    ".hh": _extract_cpp_include_specifiers,
+    ".cc": _extract_cpp_include_specifiers,
+    ".cpp": _extract_cpp_include_specifiers,
+    ".cxx": _extract_cpp_include_specifiers,
+}
+
+
 def _extract_impl_imports(file_path: Path) -> list[str]:
     """Return raw import specifiers for an implementation file.
 
-    Python impl files go through AST-based specifier extraction (the same path
-    test files use) so impl→impl import edges form for Python — the core of the
-    fix. Every other language keeps the existing quoted-specifier extractor
-    (``extract_imports``: JS/TS ``from '…'`` / ``require('…')``), unchanged.
-    Dispatch is by file suffix (DATA), mirroring ``_extract_test_imports``.
+    Python and Java impl files go through their registry-backed specifier
+    extractors (the same path test files use) so impl→impl import edges form for
+    them — the core of the fix. Every other language keeps the existing
+    quoted-specifier extractor (``extract_imports``: JS/TS ``from '…'`` /
+    ``require('…')``), unchanged. Dispatch is by file suffix (DATA).
     """
 
-    if file_path.suffix == ".py":
-        return _extract_python_import_specifiers(file_path)
+    extractor = _SUFFIX_SPECIFIER_EXTRACTORS.get(file_path.suffix)
+    if extractor is not None:
+        return extractor(file_path)
     return extract_imports(file_path)
 
 
 def _extract_test_imports(file_path: Path) -> list[str]:
     imports = extract_imports(file_path)
-    if file_path.suffix != ".py":
+    extractor = _SUFFIX_SPECIFIER_EXTRACTORS.get(file_path.suffix)
+    if extractor is None:
         return imports
 
-    # AST-based Python specifiers (relative imports included). Combined with the
-    # quoted-specifier pass above so a polyglot test file (e.g. a ``.py`` test
-    # that also embeds a JS ``require('…')`` literal in a string) keeps both.
-    return [*imports, *_extract_python_import_specifiers(file_path)]
+    # Registry-backed dotted specifiers (Python relative imports / Java FQNs)
+    # combined with the quoted-specifier pass above so a polyglot test file keeps
+    # both seams' results.
+    return [*imports, *extractor(file_path)]
 
 
 def _resolve_python_import_target(import_ref: str, project_root: Path, path_to_node: dict[Path, str]) -> str | None:
@@ -1764,8 +2106,11 @@ def _language_for_path(path: Path) -> str:
         ".cs": "csharp",
         ".c": "c",
         ".cpp": "cpp",
+        ".cc": "cpp",
+        ".cxx": "cpp",
         ".h": "cpp",
         ".hpp": "cpp",
+        ".hh": "cpp",
         ".kt": "kotlin",
         ".kts": "kotlin",
         ".swift": "swift",

codd_dev-3.7.4/codd/dag/defaults/cpp_embedded.yaml

@@ -0,0 +1,2 @@
+implementation_suffixes: [".c", ".cc", ".cpp", ".cxx", ".h", ".hpp", ".hh"]
+test_suffixes: [".cpp", ".cc", ".cxx", ".test.cpp"]

{codd_dev-3.7.2 → codd_dev-3.7.4}/codd/extractor.py

@@ -305,6 +305,11 @@ def _detect_language(project_root: Path, exclude_patterns: list[str]) -> str:
         ".py": "python", ".ts": "typescript", ".tsx": "typescript",
         ".js": "javascript", ".jsx": "javascript",
         ".java": "java", ".go": "go",
+        # C++ (incl. the common .cc/.cxx/.hh/.hpp variants). Listed as DATA so a
+        # header-heavy project like fmt (15 headers + .cc sources) is detected as
+        # ``cpp`` instead of vacuously falling back to ``python``.
+        ".cc": "cpp", ".cpp": "cpp", ".cxx": "cpp",
+        ".h": "cpp", ".hpp": "cpp", ".hh": "cpp",
     }
 
     for root, dirs, files in os.walk(project_root):
@@ -323,9 +328,24 @@ def _detect_language(project_root: Path, exclude_patterns: list[str]) -> str:
     return max(counts, key=counts.get)
 
 
+# Conventional JVM (Maven/Gradle) source / test layout. Detected by directory
+# PRESENCE (DATA), not a language gate, so a polyglot repo that happens to carry
+# this layout is handled the same way. ``src`` is deliberately NOT used as a
+# source dir when ``src/main/*`` exists, because the bare ``src`` glob would also
+# sweep in ``src/test/*`` (mixing tests into impl).
+_JVM_SOURCE_LAYOUT_DIRS = ("src/main/java", "src/main/kotlin", "src/main/scala")
+_JVM_TEST_LAYOUT_DIRS = ("src/test/java", "src/test/kotlin", "src/test/scala")
+
+
 def _detect_source_dirs(project_root: Path, language: str) -> list[str]:
     """Auto-detect source directories."""
-    candidates = ["src", "lib", "app", "pkg", "cmd", "internal"]
+    jvm_source = [d for d in _JVM_SOURCE_LAYOUT_DIRS if (project_root / d).is_dir()]
+    if jvm_source:
+        # Maven/Gradle layout: point at ``src/main/<lang>`` so the impl glob does
+        # not also pick up ``src/test/<lang>`` (which _detect_test_dirs claims).
+        return jvm_source
+
+    candidates = ["src", "lib", "app", "pkg", "cmd", "internal", "include"]
     found = []
 
     for c in candidates:
@@ -361,6 +381,12 @@ def _detect_test_dirs(project_root: Path) -> list[str]:
     for c in candidates:
         if (project_root / c).is_dir():
             found.append(c)
+    # JVM (Maven/Gradle) layout keeps tests under ``src/test/<lang>`` rather than
+    # a top-level ``tests/``. Detected by directory presence (DATA), additive so
+    # non-JVM projects are unaffected.
+    for d in _JVM_TEST_LAYOUT_DIRS:
+        if (project_root / d).is_dir():
+            found.append(d)
     return found