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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codd-dev
-Version: 3.7.2
+Version: 3.7.3
 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.3}/codd/__init__.py

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

{codd_dev-3.7.2 → codd_dev-3.7.3}/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,19 @@ 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
+
     candidates: list[Path] = []
     if _is_js_relative_specifier(import_ref):
         # JS/TS relative: ``./foo`` / ``../foo`` — resolve against the file dir
@@ -981,6 +994,119 @@ 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"
+    )
+
+
 def _infer_test_targets(
     test_path: Path,
     project_root: Path,
@@ -1025,30 +1151,89 @@ 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
+
+
+#: Suffix → raw-specifier extractor (DATA dispatch). A source file whose language
+#: carries its intra-tree dependency graph in DOTTED specifiers (Python modules,
+#: Java FQNs) 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,
+}
+
+
 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:

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

@@ -323,8 +323,23 @@ 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."""
+    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"]
     found = []
 
@@ -361,6 +376,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
 
 

{codd_dev-3.7.2 → codd_dev-3.7.3}/codd/parsing/regex_strategies.py

@@ -126,18 +126,99 @@ def _symbols_ts_js(content: str, rel_path: str) -> "list[Symbol]":
     return symbols
 
 
+#: Java type-declaration keyword → emitted symbol kind. ``record`` and the
+#: annotation type collapse to the nearest existing kind so downstream symbol
+#: consumers (which only know class/interface/enum/function) stay unchanged.
+_JAVA_TYPE_KEYWORD_KINDS = (
+    (re.compile(r'^\s*(?:public|protected|private)?\s*(?:static\s+)?(?:abstract\s+|final\s+)?class\s+(\w+)'), "class"),
+    (re.compile(r'^\s*(?:public|protected|private)?\s*(?:static\s+)?(?:abstract\s+)?interface\s+(\w+)'), "interface"),
+    (re.compile(r'^\s*(?:public|protected|private)?\s*(?:static\s+)?enum\s+(\w+)'), "enum"),
+    (re.compile(r'^\s*(?:public|protected|private)?\s*(?:static\s+)?(?:final\s+)?record\s+(\w+)'), "class"),
+)
+
+
 def _symbols_java(content: str, rel_path: str) -> "list[Symbol]":
     symbols: list = []
     for i, line in enumerate(content.splitlines(), 1):
-        m = re.match(r'^\s*(?:public|protected|private)?\s*(?:static\s+)?(?:abstract\s+)?class\s+(\w+)', line)
-        if m:
-            symbols.append(_symbol(m.group(1), "class", rel_path, i))
+        for pattern, kind in _JAVA_TYPE_KEYWORD_KINDS:
+            m = pattern.match(line)
+            if m:
+                symbols.append(_symbol(m.group(1), kind, rel_path, i))
+                break
         m = re.match(r'^\s*(?:public|protected)\s+(?:static\s+)?[\w<>\[\],\s]+\s+(\w+)\s*\(([^)]*)\)', line)
         if m and m.group(1)[0].islower():
             symbols.append(_symbol(m.group(1), "function", rel_path, i, m.group(2).strip()))
     return symbols
 
 
+#: Java stdlib / platform package roots (mirrors treesitter._JAVA_STDLIB_ROOTS).
+_JAVA_STDLIB = frozenset({"java", "javax", "jdk", "sun"})
+
+_JAVA_IMPORT_RE = re.compile(r'^\s*import\s+(static\s+)?([\w.]+(?:\.\*)?)\s*;')
+_JAVA_PACKAGE_RE = re.compile(r'^\s*package\s+([\w.]+)\s*;')
+
+
+def _imports_java(content, project_root, src_dir, file_path):
+    """Classify Java imports: first-party ``internal`` vs ``java.*``/third-party.
+
+    The regex sibling of ``treesitter._extract_java_imports_ast`` (used when
+    tree-sitter-java is unavailable). First-party = an import sharing the file's
+    own package org+domain prefix (first 2 segments, e.g. ``com.google``);
+    ``java.*``/``javax.*``/``jdk.*``/``sun.*`` and unrelated third parties are
+    external. ``stdlib`` subtraction is applied by ``RegexLanguageStrategy``.
+    """
+    internal: dict[str, list[str]] = {}
+    external: set[str] = set()
+
+    package_root = ""
+    for line in content.splitlines():
+        pm = _JAVA_PACKAGE_RE.match(line)
+        if pm:
+            package_root = pm.group(1)
+            break
+
+    root_parts = package_root.split(".") if package_root else []
+    depth = min(2, len(root_parts))
+
+    for line in content.splitlines():
+        m = _JAVA_IMPORT_RE.match(line)
+        if not m:
+            continue
+        fqn = m.group(2)
+        if fqn.endswith(".*"):
+            fqn = fqn[:-2]
+        parts = fqn.split(".")
+        top = parts[0]
+        if top in _JAVA_STDLIB:
+            external.add(fqn)
+            continue
+        if root_parts and parts[:depth] == root_parts[:depth]:
+            key = _java_internal_key(parts, root_parts)
+            internal.setdefault(key, []).append(line.strip())
+        else:
+            external.add(fqn)
+
+    return internal, external
+
+
+def _java_internal_key(fqn_parts: list[str], root_parts: list[str]) -> str:
+    """The first sub-package segment after the file's package root.
+
+    For a ``com.acme.app`` file importing ``com.acme.app.util.Helper`` the key is
+    ``util`` (the meaningful first-party sub-module), not the shared org segment.
+    Falls back to the last package segment when the import IS the package root.
+    """
+    common = 0
+    for left, right in zip(fqn_parts, root_parts):
+        if left != right:
+            break
+        common += 1
+    remainder = fqn_parts[common:]
+    if remainder:
+        return remainder[0]
+    return fqn_parts[-2] if len(fqn_parts) >= 2 else fqn_parts[0]
+
+
 def _symbols_go(content: str, rel_path: str) -> "list[Symbol]":
     symbols: list = []
     for i, line in enumerate(content.splitlines(), 1):
@@ -395,9 +476,13 @@ _JAVASCRIPT = RegexLanguageStrategy(
 _JAVA = RegexLanguageStrategy(
     name="java",
     extensions=frozenset({".java"}),
+    # stdlib stays EMPTY: the old ladder had no java stdlib set and
+    # ``common_stdlib("java")`` is pinned to ``set()``. ``_imports_java`` classifies
+    # ``java.*`` into ``external`` itself (per the Piece-2 contract) rather than
+    # relying on strategy-level stdlib subtraction.
     entry_points=("Application.java", "Main.java", "App.java"),
     extract_symbols=_symbols_java,
-    extract_imports=None,  # the old ladder had NO java import branch (no-op)
+    extract_imports=_imports_java,
     detect_code_patterns=None,  # the old ladder had NO java code-pattern branch
     file_to_module=_file_to_module_java,
     guess_test_target=None,
@@ -503,6 +588,41 @@ def _ceg_targets_python(
     return targets
 
 
+def _ceg_targets_java(
+    internal: dict, project_root: Path, file_path: Path
+) -> "list[CegImportTarget]":
+    """Java internal imports → ``module`` CEG nodes keyed by first-party FQN.
+
+    Mirrors the python resolver's module-node modelling (a stable identifier per
+    imported first-party unit) rather than probing the filesystem; the DAG
+    builder owns the precise FQN→file resolution for import EDGES. The ``internal``
+    map values are the raw import lines (``com.google.gson.internal.Streams`` /
+    ``static com.google.gson.Foo.bar``); we recover the owning FQN for the node.
+    """
+    targets: list[CegImportTarget] = []
+    seen: set[str] = set()
+    for import_lines in internal.values():
+        for line in import_lines:
+            fqn = line.strip()
+            if fqn.startswith("static "):
+                fqn = fqn[len("static "):]
+            if fqn.endswith(".*"):
+                fqn = fqn[:-2]
+            if not fqn or fqn in seen:
+                continue
+            seen.add(fqn)
+            targets.append(
+                CegImportTarget(
+                    target_id=f"module:{fqn}",
+                    node_type="module",
+                    node_kwargs={"name": fqn},
+                    evidence_method="static_import",
+                    confidence=0.90,
+                )
+            )
+    return targets
+
+
 #: Per-language scanner CEG-import resolvers (registry DATA). Languages without
 #: an entry contribute NO import edges, byte-identical to the former scanner
 #: block that only handled python and typescript/javascript.
@@ -512,6 +632,7 @@ _CEG_IMPORT_RESOLVERS: dict[
     "typescript": _ceg_targets_ts_js,
     "javascript": _ceg_targets_ts_js,
     "python": _ceg_targets_python,
+    "java": _ceg_targets_java,
 }