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

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

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

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

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

@@ -924,6 +924,19 @@ def _resolve_import_target(
                 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
@@ -1107,6 +1120,105 @@ def _sorted_java_dir_files(package_dir: Path) -> list[Path]:
     )
 
 
+#: 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,
@@ -1197,14 +1309,59 @@ def _extract_java_import_specifiers(file_path: Path) -> list[str]:
     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) 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.
+#: 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,
 }
 
 
@@ -1949,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.3 → 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):
@@ -340,7 +345,7 @@ def _detect_source_dirs(project_root: Path, language: str) -> list[str]:
         # not also pick up ``src/test/<lang>`` (which _detect_test_dirs claims).
         return jvm_source
 
-    candidates = ["src", "lib", "app", "pkg", "cmd", "internal"]
+    candidates = ["src", "lib", "app", "pkg", "cmd", "internal", "include"]
     found = []
 
     for c in candidates:

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

@@ -231,6 +231,83 @@ def _symbols_go(content: str, rel_path: str) -> "list[Symbol]":
     return symbols
 
 
+#: C++ type-declaration keyword → emitted symbol kind. ``struct`` keeps its own
+#: kind (distinct from ``class``) since it is meaningful in C++; ``enum`` (incl.
+#: ``enum class``) and ``namespace`` map to their literal kinds.
+_CPP_TYPE_KEYWORD_KINDS = (
+    (re.compile(r'^\s*(?:template\s*<[^>]*>\s*)?class\s+(\w+)'), "class"),
+    (re.compile(r'^\s*(?:template\s*<[^>]*>\s*)?struct\s+(\w+)'), "struct"),
+    (re.compile(r'^\s*enum\s+(?:class\s+|struct\s+)?(\w+)'), "enum"),
+    (re.compile(r'^\s*namespace\s+(\w+)'), "namespace"),
+)
+
+#: A free-function definition/declaration line. Deliberately conservative: a
+#: return type (one or more type tokens, optional ``*``/``&``) followed by a name
+#: and a parameter list. Excludes control-flow keywords so ``if (...)`` /
+#: ``while (...)`` / ``for (...)`` / ``switch (...)`` never read as functions.
+_CPP_FUNCTION_RE = re.compile(
+    r'^\s*(?:[\w:]+[\w:<>,\s\*&]*?\s+[\*&]?)(\w+)\s*\([^;{]*\)\s*(?:const\s*)?[{;]'
+)
+_CPP_CONTROL_KEYWORDS = frozenset({
+    "if", "for", "while", "switch", "return", "else", "do", "catch", "sizeof",
+})
+
+
+def _symbols_cpp(content: str, rel_path: str) -> "list[Symbol]":
+    symbols: list = []
+    for i, line in enumerate(content.splitlines(), 1):
+        matched_type = False
+        for pattern, kind in _CPP_TYPE_KEYWORD_KINDS:
+            m = pattern.match(line)
+            if m:
+                symbols.append(_symbol(m.group(1), kind, rel_path, i))
+                matched_type = True
+                break
+        if matched_type:
+            continue
+        m = _CPP_FUNCTION_RE.match(line)
+        if m and m.group(1) not in _CPP_CONTROL_KEYWORDS:
+            symbols.append(_symbol(m.group(1), "function", rel_path, i))
+    return symbols
+
+
+#: C++ ``#include`` directive: quote-form (``"…"`` — local/first-party) vs
+#: angle-form (``<…>`` — system/STL). Mirrors ``builder._CPP_INCLUDE_RE`` so the
+#: scan-path parser and the DAG builder agree on a C++ project's include graph.
+_CPP_INCLUDE_RE = re.compile(r'^\s*#\s*include\s*(?:"([^"]+)"|<([^>]+)>)')
+
+
+def _imports_cpp(content, project_root, src_dir, file_path):
+    """Classify C++ includes: quote-form ``internal`` vs angle-form ``external``.
+
+    The regex sibling of the DAG builder's include extraction (there is no
+    tree-sitter-cpp binding). Quote-form ``#include "demo/core.h"`` is a
+    first-party include (kept as ``internal`` with the raw line, bucketed by the
+    include path's first segment); angle-form ``#include <vector>`` is system/STL
+    (``external``, keyed by the bare header token). Returns the
+    ``(internal, external)`` shape every ``extract_imports`` strategy yields.
+    """
+    internal: dict[str, list[str]] = {}
+    external: set[str] = set()
+
+    for line in content.splitlines():
+        m = _CPP_INCLUDE_RE.match(line)
+        if not m:
+            continue
+        quote_target, angle_target = m.group(1), m.group(2)
+        if quote_target:
+            # Bucket by the first path segment (``demo`` for ``demo/core.h``); the
+            # DAG builder owns the precise path→file resolution for edges.
+            bucket = quote_target.split("/", 1)[0] or "root"
+            internal.setdefault(bucket, []).append(line.strip())
+        elif angle_target:
+            # ``<sys/types.h>`` keys on the bare top token; bare ``<vector>`` on
+            # itself. Either way it is a system/STL external.
+            external.add(angle_target)
+
+    return internal, external
+
+
 # ─────────────────────────────────────────────────────────────────────────────
 # Import extraction (verbatim bodies of the old _extract_imports ladder).
 # stdlib subtraction is applied by RegexLanguageStrategy.imports().
@@ -499,6 +576,20 @@ _GO = RegexLanguageStrategy(
     guess_test_target=None,
 )
 
+_CPP = RegexLanguageStrategy(
+    name="cpp",
+    extensions=frozenset({".c", ".cc", ".cpp", ".cxx", ".h", ".hpp", ".hh"}),
+    # stdlib stays EMPTY: ``_imports_cpp`` already classifies angle-form includes
+    # (the STL/system headers) into ``external`` itself; there is no name-set to
+    # subtract (C++ system headers are arbitrary tokens, not a fixed list).
+    entry_points=("main.cc", "main.cpp", "main.cxx"),
+    extract_symbols=_symbols_cpp,
+    extract_imports=_imports_cpp,
+    detect_code_patterns=None,
+    file_to_module=_file_to_module_first_part,
+    guess_test_target=None,
+)
+
 #: The generic fallback for an unknown language — best-effort no-op analysis,
 #: matching the implicit ``else`` of every old ladder (empty symbols/imports,
 #: no patterns, first-path-part module name, no test-target, no extensions).
@@ -513,6 +604,7 @@ _STRATEGIES: dict[str, RegexLanguageStrategy] = {
     "javascript": _JAVASCRIPT,
     "java": _JAVA,
     "go": _GO,
+    "cpp": _CPP,
 }
 
 
@@ -623,6 +715,82 @@ def _ceg_targets_java(
     return targets
 
 
+#: C/C++ include-root directory names probed when a quote-form include is not
+#: relative to the including file (mirrors ``builder._CPP_INCLUDE_ROOTS``).
+_CPP_INCLUDE_ROOTS = ("include", "src", "inc")
+_CPP_INCLUDE_LINE_RE = re.compile(r'#\s*include\s*"([^"]+)"')
+
+
+def _ceg_targets_cpp(
+    internal: dict, project_root: Path, file_path: Path
+) -> "list[CegImportTarget]":
+    """C++ quote-form includes → PATH-resolved ``file:`` CEG nodes.
+
+    Modeled on ``_ceg_targets_ts_js`` (path-resolved ``file:`` nodes), NOT the
+    Java module-node resolver — C++ resolution is PATH-based. A quote-form
+    include already carries its extension, so there is no suffix synthesis: the
+    path is resolved relative to the including file first, then under the
+    conventional include roots, and emitted as a ``file:`` node keyed by the
+    in-tree relative path. Angle-form includes never reach ``internal`` (they are
+    classified ``external`` by ``_imports_cpp``), so only first-party headers
+    become nodes.
+    """
+    targets: list[CegImportTarget] = []
+    seen: set[str] = set()
+    for include_lines in internal.values():
+        for line in include_lines:
+            match = _CPP_INCLUDE_LINE_RE.search(line)
+            if not match:
+                continue
+            spec = match.group(1)
+            resolved = _resolve_cpp_include_path(spec, project_root, file_path)
+            if resolved is None or resolved in seen:
+                continue
+            seen.add(resolved)
+            targets.append(
+                CegImportTarget(
+                    target_id=f"file:{resolved}",
+                    node_type="file",
+                    node_kwargs={"path": resolved},
+                    evidence_method="cpp_include",
+                    confidence=0.95,
+                )
+            )
+    return targets
+
+
+def _resolve_cpp_include_path(
+    spec: str, project_root: Path, file_path: Path
+) -> str | None:
+    """Resolve a quote-form include path to an in-tree posix path, or ``None``.
+
+    Tries (1) relative to the including file's directory, then (2) each
+    conventional include root walked up from the file. Returns the
+    project-relative posix path of the first candidate that exists on disk and
+    lies inside the project tree (so an out-of-tree ``../`` escape yields no
+    node → no false edge).
+    """
+    rel = Path(spec)
+    candidates = [(file_path.parent / rel)]
+    seen_roots: set[Path] = set()
+    for ancestor in [file_path.parent, *file_path.parents]:
+        for root_name in _CPP_INCLUDE_ROOTS:
+            root = (ancestor / root_name).resolve()
+            if root in seen_roots:
+                continue
+            seen_roots.add(root)
+            candidates.append(ancestor / root_name / rel)
+    for candidate in candidates:
+        resolved = candidate.resolve()
+        if not resolved.is_file():
+            continue
+        try:
+            return resolved.relative_to(project_root.resolve()).as_posix()
+        except ValueError:
+            continue
+    return None
+
+
 #: 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.
@@ -633,6 +801,7 @@ _CEG_IMPORT_RESOLVERS: dict[
     "javascript": _ceg_targets_ts_js,
     "python": _ceg_targets_python,
     "java": _ceg_targets_java,
+    "cpp": _ceg_targets_cpp,
 }
 
 

{codd_dev-3.7.3 → codd_dev-3.7.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "codd-dev"
-version = "3.7.3"
+version = "3.7.4"
 description = "CoDD: Coherence-Driven Development — cross-artifact change impact analysis"
 readme = "README.md"
 license = "MIT"

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

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