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

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

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

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

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

@@ -372,9 +372,11 @@ def _add_import_edges(
     for node_id, file_path in impl_nodes.items():
         imports = dag.nodes[node_id].attributes.get("imports", [])
         for import_ref in imports:
-            target_id = _resolve_import_target(import_ref, file_path, project_root, path_to_node, aliases)
-            if target_id and target_id != node_id:
-                dag.add_edge(Edge(from_id=node_id, to_id=target_id, kind="imports"))
+            for target_id in _resolve_import_targets(
+                import_ref, file_path, project_root, path_to_node, aliases
+            ):
+                if target_id and target_id != node_id:
+                    dag.add_edge(Edge(from_id=node_id, to_id=target_id, kind="imports"))
 
 
 def _add_tested_by_edges(
@@ -904,6 +906,29 @@ def _resolve_design_dependency(
     return None
 
 
+def _resolve_import_targets(
+    import_ref: str,
+    file_path: Path,
+    project_root: Path,
+    path_to_node: dict[Path, str],
+    aliases: dict[str, list[str]],
+) -> list[str]:
+    """Resolve one import specifier to ALL its in-tree target node ids.
+
+    Most languages have a single resolved target per specifier (Python module,
+    Java FQN, C++ ``#include`` path), so this delegates to the singular
+    ``_resolve_import_target`` and wraps its result. C# is the one intrinsically
+    MULTI-target language: a ``using`` names a namespace that many files declare,
+    so its ``.cs``-suffix branch resolves via the namespace reverse-index and may
+    return several node ids. Dispatch is by the importing file's suffix (DATA),
+    not a ``language ==`` core gate — adding a multi-target language is data.
+    """
+    if file_path.suffix == ".cs":
+        return _resolve_csharp_import_targets(import_ref, file_path, path_to_node)
+    single = _resolve_import_target(import_ref, file_path, project_root, path_to_node, aliases)
+    return [single] if single else []
+
+
 def _resolve_import_target(
     import_ref: str,
     file_path: Path,
@@ -924,6 +949,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 +1145,228 @@ 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"})
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# C# NAMESPACE reverse-index resolution (the novel mechanism for this language).
+#
+# C# is the third structural model after Java (FQN→path synthesis) and C++
+# (PATH-based include). The divergence: a C# ``using`` names a NAMESPACE, and a
+# namespace is NOT directory-tied — ``namespace Dapper;`` is declared by many
+# files spread across different directories (Dapper/, Dapper.SqlBuilder/, …).
+# There is no path to synthesize. So resolution is two-phase:
+#   (1) a first pass over the file-set builds a namespace→declaring-files reverse
+#       index (each .cs file's declared ``namespace`` lines → that file);
+#   (2) a ``using Dapper.X`` resolves to the files declaring ``namespace
+#       Dapper.X`` (EXACT namespace match), which is a SET of files, not one.
+# Because one ``using`` legitimately depends on every file of the target
+# namespace, this is the one language whose resolution is intrinsically
+# multi-target (handled by ``_resolve_import_targets`` plural).
+# ─────────────────────────────────────────────────────────────────────────────
+
+#: C# namespace declaration — both file-scoped (``namespace X.Y;``) and block
+#: (``namespace X.Y {`` / ``namespace X.Y`` then ``{`` on the next line) forms.
+#: Mirrors ``regex_strategies._CSHARP_NAMESPACE_RE``.
+_CSHARP_NAMESPACE_DECL_RE = re.compile(
+    r'^\s*namespace\s+([\w.]+)\s*[;{]?\s*$',
+    re.MULTILINE,
+)
+
+#: Cap on how many files a SINGLE ``using`` may resolve to, so a using of a very
+#: large namespace cannot explode the edge count pathologically. When a namespace
+#: is declared by more files than this, we keep the edges deterministic (sorted)
+#: and truncate; the WARN-level reachability layer still sees a connected node.
+#: Generous enough that real same-namespace fan-out (Dapper declares its core
+#: namespace across ~dozens of files) is preserved.
+_CSHARP_NAMESPACE_FANOUT_CAP = 64
+
+#: Process-lifetime cache of the namespace reverse-index, keyed by the IDENTITY +
+#: size of the ``path_to_node`` map. ``_add_import_edges`` / ``_add_tested_by_edges``
+#: each build a fresh ``path_to_node`` and reuse it across every import in their
+#: loop, so caching by ``id()`` (guarded by ``len()`` against id-reuse after GC)
+#: builds the index ONCE per DAG-build phase instead of per-using.
+_CSHARP_NS_INDEX_CACHE: dict[tuple[int, int], dict[str, list[str]]] = {}
+
+
+def _csharp_namespace_index(path_to_node: dict[Path, str]) -> dict[str, list[str]]:
+    """Return the namespace→declaring-node-ids reverse-index (built once, cached).
+
+    First pass over the .cs file-set: every ``namespace X.Y`` declared in a file
+    (file-scoped OR block form) maps that namespace to the file's node id. A file
+    may declare multiple namespaces; a namespace may be declared by many files
+    (the whole point — namespaces are not directory-tied). Node-id lists are kept
+    sorted for deterministic edge output.
+    """
+    key = (id(path_to_node), len(path_to_node))
+    cached = _CSHARP_NS_INDEX_CACHE.get(key)
+    if cached is not None:
+        return cached
+
+    index: dict[str, set[str]] = {}
+    for file_path, node_id in path_to_node.items():
+        if file_path.suffix != ".cs":
+            continue
+        try:
+            content = file_path.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+        for namespace in _CSHARP_NAMESPACE_DECL_RE.findall(content):
+            index.setdefault(namespace, set()).add(node_id)
+
+    materialized = {ns: sorted(ids) for ns, ids in index.items()}
+    _CSHARP_NS_INDEX_CACHE[key] = materialized
+    return materialized
+
+
+def _csharp_using_namespaces(import_ref: str) -> list[str]:
+    """Candidate namespaces to look up for one ``using`` specifier (most-specific first).
+
+    * plain / global / alias ``using Dapper.X`` → ``["Dapper.X"]`` (exact).
+    * ``static Dapper.SqlMapper`` → ``["Dapper.SqlMapper", "Dapper"]``: a
+      ``using static`` targets a TYPE (``Dapper.SqlMapper``), whose declaring file
+      lives in the type's OWNING namespace (``Dapper``). We try the full path as a
+      namespace first (harmless if it is not one — just no match), then the parent
+      namespace (drop the type segment), which is the real resolution.
+    """
+    spec = import_ref
+    is_static = spec.startswith(_CSHARP_STATIC_SPECIFIER)
+    if is_static:
+        spec = spec[len(_CSHARP_STATIC_SPECIFIER):].strip()
+    if not spec:
+        return []
+    candidates = [spec]
+    if is_static:
+        parent = spec.rsplit(".", 1)[0] if "." in spec else ""
+        if parent and parent != spec:
+            candidates.append(parent)
+    return candidates
+
+
+def _resolve_csharp_import_targets(
+    import_ref: str,
+    file_path: Path,
+    path_to_node: dict[Path, str],
+) -> list[str]:
+    """Resolve one C# ``using`` to the node ids declaring its namespace (EXACT).
+
+    Sub-namespace handling: resolution is by EXACT namespace match only. A
+    ``using Dapper`` resolves to files declaring exactly ``namespace Dapper`` — it
+    does NOT transitively pull in ``Dapper.Tests`` / ``Dapper.SqlBuilder`` files.
+    This is both correct (a parent-namespace using does not import child
+    namespaces in C#; each child needs its own ``using``) and the primary
+    explosion guard (no namespace-prefix fan-out). For a ``using static`` the
+    type's owning namespace is the fallback candidate (see
+    ``_csharp_using_namespaces``); the first candidate that matches the index
+    wins, so a static import does not double-count.
+
+    Secondary explosion guard: a single using that matches a very large namespace
+    is truncated at ``_CSHARP_NAMESPACE_FANOUT_CAP`` (deterministic, sorted).
+    """
+    index = _csharp_namespace_index(path_to_node)
+    for namespace in _csharp_using_namespaces(import_ref):
+        node_ids = index.get(namespace)
+        if node_ids:
+            return node_ids[:_CSHARP_NAMESPACE_FANOUT_CAP]
+    return []
+
+
 def _infer_test_targets(
     test_path: Path,
     project_root: Path,
@@ -1116,11 +1376,15 @@ def _infer_test_targets(
     targets: set[str] = set()
 
     for import_ref in _extract_test_imports(test_path):
-        target_id = _resolve_import_target(import_ref, test_path, project_root, path_to_node, aliases)
-        if not target_id and "." in import_ref and not import_ref.startswith("."):
-            target_id = _resolve_python_import_target(import_ref, project_root, path_to_node)
-        if target_id:
-            targets.add(target_id)
+        resolved = _resolve_import_targets(import_ref, test_path, project_root, path_to_node, aliases)
+        if not resolved and "." in import_ref and not import_ref.startswith("."):
+            # Python absolute-dotted fallback (non-C#: the plural resolver returns
+            # at most one for those). C# usings already resolve via the namespace
+            # index inside ``_resolve_import_targets``, so this never double-fires.
+            python_target = _resolve_python_import_target(import_ref, project_root, path_to_node)
+            if python_target:
+                resolved = [python_target]
+        targets.update(resolved)
 
     convention_key = _test_convention_key(test_path, project_root)
     if convention_key:
@@ -1197,14 +1461,102 @@ 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
+
+
+# C# ``using`` directives. Unlike C++ ``#include`` (path) or Java FQN→path, a C#
+# ``using`` names a NAMESPACE, which is NOT directory-tied — ``namespace Dapper;``
+# is declared across files in different dirs. So the resolver needs a
+# namespace→declaring-files reverse-index (built once over the file-set), not a
+# path probe. The extractor's job is just to surface the raw using forms:
+#   ``using X.Y;``              → ``X.Y``
+#   ``using static X.Y.Member;``→ ``static X.Y.Member``  (resolver drops Member)
+#   ``using Alias = X.Y;``      → ``X.Y``  (alias name is irrelevant to edges)
+#   ``global using X.Y;``       → ``X.Y``
+# Built-in regex (NOT routed through the registry): tree-sitter-c-sharp is NOT
+# installed, and ``RegexExtractor.extract_import_specifiers`` returns ``[]`` for
+# C#, so a self-contained regex is the source of these specifiers (mirrors the
+# C++ precedent of deferring tree-sitter wiring). The ``static`` marker is the
+# only shape distinction the resolver needs.
+_CSHARP_STATIC_SPECIFIER = "static "
+_CSHARP_USING_RE = re.compile(
+    r'^\s*(?:global\s+)?using\s+(static\s+)?(?:[\w.]+\s*=\s*)?([\w.]+)\s*;',
+    re.MULTILINE,
+)
+
+
+def _extract_csharp_import_specifiers(file_path: Path) -> list[str]:
+    """Return raw C# ``using`` specifiers (static-marked) for the DAG.
+
+    Mirrors ``_extract_cpp_include_specifiers`` / ``_extract_java_import_specifiers``
+    in role (suffix-dispatched raw specifier extraction) but uses a built-in
+    regex because tree-sitter-c-sharp is absent. ``using static X.Y.Member`` is
+    surfaced with a ``static `` prefix so the NAMESPACE-index resolver knows to
+    also try the parent namespace (the member's owning type's namespace); plain /
+    global / alias usings are surfaced as the bare imported namespace.
+    """
+
+    content = file_path.read_text(encoding="utf-8", errors="ignore")
+    specifiers: list[str] = []
+    for static_kw, namespace in _CSHARP_USING_RE.findall(content):
+        if static_kw:
+            specifiers.append(f"{_CSHARP_STATIC_SPECIFIER}{namespace}")
+        else:
+            specifiers.append(namespace)
+    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, C# namespaces) 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,
+    ".cs": _extract_csharp_import_specifiers,
 }
 
 
@@ -1246,6 +1598,22 @@ def _resolve_python_import_target(import_ref: str, project_root: Path, path_to_n
     return path_to_node.get(init_path)
 
 
+#: ESM/TS extension-swap map (DATA, not a ``language ==`` branch). Under
+#: ``moduleResolution: NodeNext``/``Bundler`` a TypeScript import specifier MUST
+#: carry the EMITTED ``.js`` extension that resolves to the ``.ts`` SOURCE file
+#: (``import { x } from "./types.js"`` → ``types.ts``). Each emitted suffix maps
+#: to the source suffixes it can stand in for. Resolution tries these ONLY as a
+#: last-resort fallback (after exact-match and bare suffix-append both fail), so
+#: a real ``./foo.js`` target still wins by exact match — JS projects with real
+#: ``.js`` files are unaffected.
+_ESM_EXTENSION_SWAP: dict[str, tuple[str, ...]] = {
+    ".js": (".ts", ".tsx"),
+    ".jsx": (".tsx", ".ts"),
+    ".mjs": (".mts", ".ts"),
+    ".cjs": (".cts", ".ts"),
+}
+
+
 def _resolve_file_candidate(candidate: Path, path_to_node: dict[Path, str]) -> str | None:
     if candidate in path_to_node:
         return path_to_node[candidate]
@@ -1263,6 +1631,26 @@ def _resolve_file_candidate(candidate: Path, path_to_node: dict[Path, str]) -> s
     init_file = candidate / "__init__.py"
     if init_file in path_to_node:
         return path_to_node[init_file]
+
+    # FALLBACK (only after exact-match + suffix-append + index/__init__ all
+    # failed): the specifier carries an emitted ESM extension (``.js``/…) that
+    # should resolve to a ``.ts`` SOURCE file. Swap the emitted suffix for each
+    # candidate source suffix and retry both the file form (``./types.js`` →
+    # ``types.ts``) and the directory-index form (``./foo.js`` → ``foo/index.ts``).
+    source_suffixes = _ESM_EXTENSION_SWAP.get(candidate.suffix)
+    if source_suffixes:
+        # Strip ONLY the trailing emitted suffix as a string so inner dots are
+        # preserved (``types.test.js`` → base ``types.test``, not ``types``).
+        stem = candidate.name[: -len(candidate.suffix)]
+        swapped_base = candidate.parent / stem
+        for source_suffix in source_suffixes:
+            swapped = candidate.parent / f"{stem}{source_suffix}"
+            if swapped in path_to_node:
+                return path_to_node[swapped]
+        for source_suffix in source_suffixes:
+            indexed = swapped_base / f"index{source_suffix}"
+            if indexed in path_to_node:
+                return path_to_node[indexed]
     return None
 
 
@@ -1949,8 +2337,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.5/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.5}/codd/extractor.py

@@ -305,6 +305,16 @@ 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",
+        # C# (.cs). Listed as DATA so a C# project like Dapper (157 .cs files,
+        # no .py at all) is detected as ``csharp`` instead of vacuously falling
+        # back to ``python`` — the single change that fixes the false-green where
+        # ``codd check`` PASSes on a 0-edge graph because the .cs files were inert.
+        ".cs": "csharp",
     }
 
     for root, dirs, files in os.walk(project_root):
@@ -340,7 +350,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: