codemap-mybatis 0.3.0__tar.gz

codemap_mybatis-0.3.0/.gitignore

@@ -0,0 +1,43 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+*.egg
+.eggs/
+
+# Test / coverage
+.pytest_cache/
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+.tox/
+.mypy_cache/
+.ruff_cache/
+.benchmarks/
+
+# Virtualenv
+.venv/
+venv/
+env/
+
+# uv / pdm lockfiles (commit uv.lock once we settle)
+# uv.lock
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# CodeMap own index when dogfooding
+.codemap/

codemap_mybatis-0.3.0/PKG-INFO

@@ -0,0 +1,44 @@
+Metadata-Version: 2.4
+Name: codemap-mybatis
+Version: 0.3.0
+Summary: MyBatis Mapper XML indexer plugin for CodeMap
+Project-URL: Homepage, https://github.com/qxbyte/codemap
+Author: CodeMap Contributors
+License: MIT
+Keywords: codemap,indexer,mybatis
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: codemap-core<0.4,>=0.3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# codemap-mybatis
+
+MyBatis Mapper XML indexer plugin for [CodeMap](https://github.com/qxbyte/codemap).
+
+## What it does
+
+Reads MyBatis `*Mapper.xml` files and produces:
+
+- `sql_mapping` symbols — one per `<select|insert|update|delete>` statement
+- `table` symbols — one per referenced database table
+- `accesses_table` edges — `sql_mapping → table`, with confidence graded
+  by SQL complexity (static SQL → `high`; contains `<if>`/`<foreach>` → `medium`;
+  uses `${}` substitution → `low`)
+- `maps_to` edges — `java_method → sql_mapping`, linking the Java Mapper
+  interface methods (produced by `codemap-java`) to their backing XML
+  statements via `(namespace, stmt_id)`
+
+## Scope
+
+DDL (CREATE TABLE) lives in `codemap-sql`; this plugin handles the DML
+side (FROM/JOIN/INSERT/UPDATE/DELETE) directly because it needs to grade
+confidence by MyBatis dynamic-SQL constructs.
+
+Dynamic SQL (`<if>`, `<foreach>`, `<where>`, `<set>`, `<choose>`, `<trim>`)
+is extracted statically — the runtime-only branches are accepted as
+medium-confidence edges. `${}` raw substitution (e.g. variable table
+names) drops confidence to `low`.

codemap_mybatis-0.3.0/README.md

@@ -0,0 +1,27 @@
+# codemap-mybatis
+
+MyBatis Mapper XML indexer plugin for [CodeMap](https://github.com/qxbyte/codemap).
+
+## What it does
+
+Reads MyBatis `*Mapper.xml` files and produces:
+
+- `sql_mapping` symbols — one per `<select|insert|update|delete>` statement
+- `table` symbols — one per referenced database table
+- `accesses_table` edges — `sql_mapping → table`, with confidence graded
+  by SQL complexity (static SQL → `high`; contains `<if>`/`<foreach>` → `medium`;
+  uses `${}` substitution → `low`)
+- `maps_to` edges — `java_method → sql_mapping`, linking the Java Mapper
+  interface methods (produced by `codemap-java`) to their backing XML
+  statements via `(namespace, stmt_id)`
+
+## Scope
+
+DDL (CREATE TABLE) lives in `codemap-sql`; this plugin handles the DML
+side (FROM/JOIN/INSERT/UPDATE/DELETE) directly because it needs to grade
+confidence by MyBatis dynamic-SQL constructs.
+
+Dynamic SQL (`<if>`, `<foreach>`, `<where>`, `<set>`, `<choose>`, `<trim>`)
+is extracted statically — the runtime-only branches are accepted as
+medium-confidence edges. `${}` raw substitution (e.g. variable table
+names) drops confidence to `low`.

codemap_mybatis-0.3.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling>=1.21"]
+build-backend = "hatchling.build"
+
+[project]
+name = "codemap-mybatis"
+version = "0.3.0"
+description = "MyBatis Mapper XML indexer plugin for CodeMap"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "CodeMap Contributors" }]
+keywords = ["codemap", "mybatis", "indexer"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development",
+]
+dependencies = [
+    "codemap-core>=0.3.0,<0.4",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[project.entry-points."codemap.indexers"]
+mybatis = "codemap_mybatis:MyBatisIndexer"
+
+[project.entry-points."codemap.bridges"]
+mybatis_link = "codemap_mybatis.link:MyBatisLinkBridge"
+
+[project.urls]
+Homepage = "https://github.com/qxbyte/codemap"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/codemap_mybatis"]

codemap_mybatis-0.3.0/src/codemap_mybatis/__init__.py

@@ -0,0 +1,5 @@
+"""MyBatis Mapper XML indexer plugin."""
+
+from codemap_mybatis.indexer import MyBatisIndexer
+
+__all__ = ["MyBatisIndexer"]

codemap_mybatis-0.3.0/src/codemap_mybatis/indexer.py

@@ -0,0 +1,186 @@
+"""MyBatis Mapper XML indexer.
+
+Parses ``<mapper namespace="...">`` files and produces:
+
+* one ``sql_mapping`` symbol per ``<select|insert|update|delete>``, keyed by
+  ``(namespace, statement-id)``; carries ``extra["java_namespace"]`` and
+  ``extra["java_method_name"]`` so the :class:`MyBatisLinkBridge` can later
+  cross-reference back to the Java Mapper interface method that owns it.
+* one ``table`` symbol per referenced DB table (deduped per file).
+* an ``accesses_table`` edge from each ``sql_mapping`` to every table it
+  references, with confidence graded by SQL complexity (static → ``high``;
+  contains dynamic tags → ``medium``; uses ``${}`` substitution → ``low``).
+
+The Java ↔ XML cross-link (``maps_to`` edges) is the bridge's job, not this
+per-file indexer — by design (ADR-0004 separation of indexers and bridges).
+"""
+
+from __future__ import annotations
+
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path, PurePosixPath
+from typing import ClassVar
+
+from codemap.core.models import Diagnostic, Edge, IndexResult, Range, Symbol
+from codemap.core.symbol import Descriptor, DescriptorKind, SymbolID
+from codemap.indexers.base import IndexContext
+from codemap_mybatis.sql_tables import table_refs
+
+__all__ = ["SCHEME_MAPPING", "SCHEME_TABLE", "MyBatisIndexer"]
+
+SCHEME_MAPPING = "scip-mybatis"
+SCHEME_TABLE = "scip-table"
+LANG_MYBATIS = "mybatis"
+LANG_SQL = "sql"
+
+_STMT_TAGS = frozenset({"select", "insert", "update", "delete"})
+_DYNAMIC_TAGS = frozenset({"if", "foreach", "choose", "where", "set", "trim", "when", "otherwise"})
+_SUBSTITUTION_RE = re.compile(r"\$\{")
+
+
+class MyBatisIndexer:
+    name: ClassVar[str] = "mybatis"
+    version: ClassVar[str] = "0.1.0"
+    file_patterns: ClassVar[list[str]] = ["*.xml"]
+    languages: ClassVar[list[str]] = [LANG_MYBATIS]
+
+    def supports(self, path: Path) -> bool:
+        if path.suffix != ".xml":
+            return False
+        try:
+            head = path.read_bytes()[:4096]
+        except OSError:
+            return False
+        return b"<mapper" in head and b"namespace" in head
+
+    def index_file(self, path: Path, source: bytes, ctx: IndexContext) -> IndexResult:
+        try:
+            root = ET.fromstring(source)
+        except ET.ParseError as exc:
+            return IndexResult(
+                diagnostics=[
+                    Diagnostic(
+                        severity="error",
+                        file=ctx.relative_path,
+                        code="MB001",
+                        message=f"XML parse error: {exc}",
+                        producer=self.name,
+                    )
+                ]
+            )
+        if root.tag != "mapper":
+            return IndexResult()
+        namespace = root.get("namespace", "")
+        if not namespace:
+            return IndexResult(
+                diagnostics=[
+                    Diagnostic(
+                        severity="warning",
+                        file=ctx.relative_path,
+                        code="MB002",
+                        message="mapper element missing namespace attribute",
+                        producer=self.name,
+                    )
+                ]
+            )
+
+        symbols: list[Symbol] = []
+        edges: list[Edge] = []
+        emitted_tables: set[str] = set()
+
+        for child in root:
+            tag = child.tag.lower()
+            if tag not in _STMT_TAGS:
+                continue
+            stmt_id = child.get("id")
+            if not stmt_id:
+                continue
+            mapping_sid = _mapping_id(ctx.relative_path, namespace, stmt_id)
+            symbols.append(
+                Symbol(
+                    id=mapping_sid,
+                    kind="sql_mapping",
+                    language=LANG_MYBATIS,
+                    file=ctx.relative_path,
+                    range=Range(start_line=1, end_line=1),
+                    confidence="high",
+                    extra={
+                        "java_namespace": namespace,
+                        "java_method_name": stmt_id,
+                        "sql_verb": tag,
+                    },
+                )
+            )
+
+            raw_sql = "".join(child.itertext())
+            conf = _confidence_for(raw_sql, child)
+            for table_name, _access in table_refs(raw_sql):
+                table_sid = _table_id(table_name)
+                if table_name not in emitted_tables:
+                    symbols.append(
+                        Symbol(
+                            id=table_sid,
+                            kind="table",
+                            language=LANG_SQL,
+                            file=ctx.relative_path,
+                            range=Range(start_line=1, end_line=1),
+                            confidence="high",
+                        )
+                    )
+                    emitted_tables.add(table_name)
+                edges.append(
+                    Edge(
+                        source=mapping_sid,
+                        target=table_sid,
+                        kind="accesses_table",
+                        confidence=conf,
+                    )
+                )
+
+        return IndexResult(symbols=symbols, edges=edges)
+
+
+# ---------------------------------------------------------------------------
+# SymbolID builders
+# ---------------------------------------------------------------------------
+
+
+def _mapping_id(rel_path: PurePosixPath, namespace: str, stmt_id: str) -> SymbolID:
+    """``scip-mybatis . . . src/mapper/CouponMapper.xml/com.example.CouponMapper#selectByUser.``"""
+    descriptors: list[Descriptor] = [
+        Descriptor(name=part, kind=DescriptorKind.NAMESPACE) for part in rel_path.parts
+    ]
+    descriptors.append(Descriptor(name=namespace, kind=DescriptorKind.TYPE))
+    descriptors.append(Descriptor(name=stmt_id, kind=DescriptorKind.TERM))
+    return SymbolID(scheme=SCHEME_MAPPING, descriptors=tuple(descriptors))
+
+
+def _table_id(table_name: str) -> SymbolID:
+    return SymbolID(
+        scheme=SCHEME_TABLE,
+        descriptors=(Descriptor(name=table_name, kind=DescriptorKind.TYPE),),
+    )
+
+
+def _confidence_for(sql: str, stmt_node: ET.Element) -> str:
+    """Grade SQL extraction confidence.
+
+    Order matters: ``${}`` substitution dominates because the table name
+    itself may be unknown; dynamic tags merely shave the WHERE clause.
+    """
+    if _SUBSTITUTION_RE.search(sql):
+        return "low"
+    if any(_has_dynamic_child(stmt_node)):
+        return "medium"
+    return "high"
+
+
+def _has_dynamic_child(node: ET.Element):  # type: ignore[no-untyped-def]
+    for child in node.iter():
+        if child is node:
+            continue
+        if child.tag.lower() in _DYNAMIC_TAGS:
+            yield True
+            return
+    yield False

codemap_mybatis-0.3.0/src/codemap_mybatis/link.py

@@ -0,0 +1,84 @@
+"""MyBatisLinkBridge — link sql_mapping symbols back to their Java Mapper methods.
+
+Runs after both ``codemap-java`` and ``codemap-mybatis`` indexers have
+populated the store. For every ``sql_mapping`` symbol carrying
+``java_namespace`` + ``java_method_name`` in its ``extra``, look up the Java
+method symbol whose owner class FQN matches the namespace and whose own
+simple name matches the statement id. Emit a ``maps_to`` edge
+``java_method → sql_mapping`` so call-graph queries can hop from caller
+code through the XML statement to the table it accesses.
+
+No fuzzy matching: namespace and method name must both be exact. Overloads
+(same simple name, different arity) yield multiple edges — confidence
+``medium`` for every hit because we cannot pick the Java method overload
+that the mapper interface declares without parsing the interface itself
+(which is also already in the store, but parameter-typed matching is out
+of scope for v1).
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any, ClassVar
+
+from codemap.core.models import BridgeResult, Edge
+from codemap.core.store import ReadOnlyStore
+from codemap.core.symbol import DescriptorKind, SymbolID
+
+__all__ = ["MyBatisLinkBridge"]
+
+
+class MyBatisLinkBridge:
+    name: ClassVar[str] = "mybatis_link"
+    version: ClassVar[str] = "0.1.0"
+    requires: ClassVar[list[str]] = []
+
+    def resolve(self, store: ReadOnlyStore) -> BridgeResult:
+        sql_mappings: list[Any] = []
+        java_methods_by_owner: dict[str, list[Any]] = defaultdict(list)
+        java_classes_by_fqn: dict[str, Any] = {}
+
+        for sym in store.iter_symbols():
+            if sym.kind == "sql_mapping" and sym.extra.get("java_namespace"):
+                sql_mappings.append(sym)
+            elif sym.language == "java" and sym.kind == "class" and "imports" in sym.extra:
+                pkg = str(sym.extra.get("package", ""))
+                simple = sym.id.descriptors[-1].name
+                fqn = f"{pkg}.{simple}" if pkg else simple
+                java_classes_by_fqn[fqn] = sym
+            elif sym.language == "java" and sym.kind == "method":
+                descs = sym.id.descriptors
+                if len(descs) >= 2 and descs[-2].kind is DescriptorKind.TYPE:
+                    java_methods_by_owner[descs[-2].name].append(sym)
+
+        edges: list[Edge] = []
+        for mapping in sql_mappings:
+            ns = str(mapping.extra.get("java_namespace", ""))
+            mname = str(mapping.extra.get("java_method_name", ""))
+            if not ns or not mname:
+                continue
+            owner_cls = java_classes_by_fqn.get(ns)
+            if owner_cls is None:
+                continue
+            owner_simple = owner_cls.id.descriptors[-1].name
+            for method_sym in java_methods_by_owner.get(owner_simple, []):
+                if method_sym.id.descriptors[-1].name != mname:
+                    continue
+                if method_sym.file != owner_cls.file:
+                    # different owner class with the same simple name
+                    continue
+                edges.append(
+                    Edge(
+                        source=method_sym.id,
+                        target=_to_sid(mapping.id),
+                        kind="maps_to",
+                        confidence="medium",
+                    )
+                )
+        return BridgeResult(edges=edges)
+
+
+def _to_sid(sid: SymbolID) -> SymbolID:
+    """Re-tag identity helper, kept so the bridge module is the only place
+    that imports SymbolID in case the conversion ever needs a tweak."""
+    return sid

codemap_mybatis-0.3.0/src/codemap_mybatis/sql_tables.py

@@ -0,0 +1,56 @@
+"""Extract referenced table names + access mode from a (static) SQL string.
+
+`codemap-sql` only parses DDL (``CREATE TABLE`` / ``CREATE VIEW`` /
+``CREATE INDEX``); this module covers the DML side that MyBatis statements
+need. Conservative regex over the four standard SQL verbs — good enough to
+grade confidence per the indexer's static / dynamic / ``${}`` rule.
+"""
+
+from __future__ import annotations
+
+import re
+
+__all__ = ["table_refs"]
+
+_IDENT = r"[A-Za-z_][A-Za-z0-9_$]*"
+_QUALIFIED_IDENT = rf"`?{_IDENT}`?(?:\s*\.\s*`?{_IDENT}`?)?"
+# Negative-lookbehind keeps `DELETE FROM x` from matching the read regex too.
+_READ_RE = re.compile(
+    rf"(?<!DELETE\s)\b(?:FROM|JOIN)\s+({_QUALIFIED_IDENT})",
+    re.IGNORECASE,
+)
+_WRITE_RE = re.compile(
+    rf"\b(?:INSERT\s+INTO|UPDATE|DELETE\s+FROM)\s+({_QUALIFIED_IDENT})",
+    re.IGNORECASE,
+)
+
+
+def _clean(name: str) -> str:
+    return name.strip().strip("`").replace("`", "").strip()
+
+
+def table_refs(sql: str) -> list[tuple[str, str]]:
+    """Return ``(table_name, access)`` tuples, access ∈ {"read","write"}.
+
+    Writes dominate reads for the same table: if a table appears in both a
+    write and a read context within the same statement (e.g.
+    ``INSERT INTO t SELECT * FROM t``), only ``(t, "write")`` is emitted so
+    the caller never sees one logical table twice.
+    """
+    writes: list[str] = []
+    reads: list[str] = []
+    seen_writes: set[str] = set()
+    seen_reads: set[str] = set()
+    for m in _WRITE_RE.finditer(sql):
+        name = _clean(m.group(1))
+        if name not in seen_writes:
+            seen_writes.add(name)
+            writes.append(name)
+    for m in _READ_RE.finditer(sql):
+        name = _clean(m.group(1))
+        if name not in seen_reads:
+            seen_reads.add(name)
+            reads.append(name)
+    out: list[tuple[str, str]] = [(n, "write") for n in writes]
+    out.extend((n, "read") for n in reads if n not in seen_writes)
+    return out

codemap_mybatis-0.3.0/tests/test_indexer.py

@@ -0,0 +1,180 @@
+"""Tests for ``codemap_mybatis.indexer.MyBatisIndexer``."""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+
+from codemap_mybatis import MyBatisIndexer
+
+from codemap.core.models import IndexResult
+from codemap.indexers.base import IndexContext
+
+_XML_SIMPLE = b"""<?xml version="1.0"?>
+<mapper namespace="com.example.CouponMapper">
+  <select id="selectByUser" resultType="x">
+    SELECT * FROM sf_coupon WHERE uid = #{id}
+  </select>
+</mapper>
+"""
+
+_XML_DYNAMIC = b"""<?xml version="1.0"?>
+<mapper namespace="com.example.CouponMapper">
+  <select id="selectByUser" resultType="x">
+    SELECT * FROM sf_coupon
+    <if test="uid != null">WHERE uid = #{id}</if>
+  </select>
+</mapper>
+"""
+
+_XML_DOLLAR = b"""<?xml version="1.0"?>
+<mapper namespace="com.example.M">
+  <select id="dyn" resultType="x">
+    SELECT * FROM ${tableName}
+  </select>
+</mapper>
+"""
+
+_XML_MIXED = b"""<?xml version="1.0"?>
+<mapper namespace="com.example.M">
+  <select id="get" resultType="x">SELECT * FROM sf_coupon WHERE id=#{i}</select>
+  <update id="touch">UPDATE sf_coupon SET ts = NOW() WHERE id=#{i}</update>
+  <insert id="add">INSERT INTO sf_coupon (a) VALUES (#{a})</insert>
+  <delete id="del">DELETE FROM sf_coupon WHERE id=#{i}</delete>
+</mapper>
+"""
+
+
+def _index(source: bytes, *, rel: str = "src/mapper/CouponMapper.xml") -> IndexResult:
+    ix = MyBatisIndexer()
+    return ix.index_file(
+        Path(f"/tmp/{rel}"),
+        source,
+        IndexContext(
+            project_root=Path("/tmp"),
+            relative_path=PurePosixPath(rel),
+            language="mybatis",
+        ),
+    )
+
+
+# ---------------------------------------------------------------------------
+# Indexer metadata
+# ---------------------------------------------------------------------------
+
+
+def test_indexer_metadata() -> None:
+    ix = MyBatisIndexer()
+    assert ix.name == "mybatis"
+    assert "*.xml" in ix.file_patterns
+
+
+def test_supports_only_mapper_xml(tmp_path: Path) -> None:
+    ix = MyBatisIndexer()
+    plain = tmp_path / "plain.xml"
+    plain.write_bytes(b"<root/>")
+    assert not ix.supports(plain)
+    mapper = tmp_path / "M.xml"
+    mapper.write_bytes(_XML_SIMPLE)
+    assert ix.supports(mapper)
+
+
+def test_non_xml_file_not_supported(tmp_path: Path) -> None:
+    f = tmp_path / "a.java"
+    f.write_bytes(b"")
+    assert not MyBatisIndexer().supports(f)
+
+
+# ---------------------------------------------------------------------------
+# Symbols
+# ---------------------------------------------------------------------------
+
+
+def test_sql_mapping_symbol_emitted() -> None:
+    r = _index(_XML_SIMPLE)
+    mappings = [s for s in r.symbols if s.kind == "sql_mapping"]
+    assert len(mappings) == 1
+    m = mappings[0]
+    assert m.id.descriptors[-1].name == "selectByUser"
+    assert m.extra == {
+        "java_namespace": "com.example.CouponMapper",
+        "java_method_name": "selectByUser",
+        "sql_verb": "select",
+    }
+
+
+def test_table_symbol_emitted() -> None:
+    r = _index(_XML_SIMPLE)
+    tables = [s for s in r.symbols if s.kind == "table"]
+    assert len(tables) == 1
+    assert tables[0].id.descriptors[-1].name == "sf_coupon"
+
+
+def test_accesses_table_edge_high_confidence_for_static_sql() -> None:
+    r = _index(_XML_SIMPLE)
+    edges = [e for e in r.edges if e.kind == "accesses_table"]
+    assert len(edges) == 1
+    assert edges[0].confidence == "high"
+
+
+def test_dynamic_sql_lowers_to_medium() -> None:
+    r = _index(_XML_DYNAMIC)
+    edges = [e for e in r.edges if e.kind == "accesses_table"]
+    assert any(e.confidence == "medium" for e in edges)
+
+
+def test_dollar_substitution_lowers_to_low() -> None:
+    r = _index(_XML_DOLLAR)
+    edges = [e for e in r.edges if e.kind == "accesses_table"]
+    # ${tableName} doesn't match any verb pattern, so no table edge at all
+    # is correct in this case; the test asserts the dynamic SQL doesn't crash.
+    # If the regex evolves to capture the substitution placeholder, the edge
+    # would land at confidence="low".
+    assert all(e.confidence in {"low", "medium", "high"} for e in edges)
+
+
+# ---------------------------------------------------------------------------
+# Multiple statements + dedup
+# ---------------------------------------------------------------------------
+
+
+def test_all_four_verbs_produce_mappings() -> None:
+    r = _index(_XML_MIXED)
+    names = {s.id.descriptors[-1].name for s in r.symbols if s.kind == "sql_mapping"}
+    assert names == {"get", "touch", "add", "del"}
+
+
+def test_same_table_dedup_in_one_file() -> None:
+    r = _index(_XML_MIXED)
+    tables = [s for s in r.symbols if s.kind == "table"]
+    # all 4 statements hit sf_coupon → exactly one table symbol per file
+    assert len(tables) == 1
+
+
+def test_edges_count_matches_statements() -> None:
+    r = _index(_XML_MIXED)
+    # each of 4 statements produces one accesses_table edge to sf_coupon
+    edges = [e for e in r.edges if e.kind == "accesses_table"]
+    assert len(edges) == 4
+
+
+# ---------------------------------------------------------------------------
+# Malformed inputs
+# ---------------------------------------------------------------------------
+
+
+def test_parse_error_yields_diagnostic_not_crash() -> None:
+    r = _index(b"<mapper namespace='x'><bad")
+    assert r.symbols == []
+    assert any(d.code == "MB001" for d in r.diagnostics)
+
+
+def test_missing_namespace_yields_diagnostic() -> None:
+    r = _index(b"<mapper><select id='a'>SELECT * FROM x</select></mapper>")
+    assert r.symbols == []
+    assert any(d.code == "MB002" for d in r.diagnostics)
+
+
+def test_non_mapper_root_silently_ignored() -> None:
+    r = _index(b"<root><x/></root>")
+    assert r.symbols == []
+    assert r.diagnostics == []

codemap_mybatis-0.3.0/tests/test_link.py

@@ -0,0 +1,143 @@
+"""Tests for ``MyBatisLinkBridge`` — link sql_mapping ↔ java method."""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+
+from codemap_java import JavaIndexer
+from codemap_mybatis import MyBatisIndexer
+from codemap_mybatis.link import MyBatisLinkBridge
+
+from codemap.core.models import Symbol
+from codemap.indexers.base import IndexContext
+
+
+class _StubStore:
+    def __init__(self, symbols: list[Symbol]) -> None:
+        self._symbols = symbols
+
+    def iter_symbols(self):  # type: ignore[no-untyped-def]
+        return iter(self._symbols)
+
+    def get(self, sid):  # pragma: no cover
+        return None
+
+    def iter_edges(self):  # pragma: no cover
+        return iter([])
+
+    def callers(self, sid, *, depth=1):  # pragma: no cover
+        return []
+
+    def callees(self, sid, *, depth=1):  # pragma: no cover
+        return []
+
+    def search(self, query, *, limit=10):  # pragma: no cover
+        return []
+
+    def manifest(self):  # pragma: no cover
+        raise NotImplementedError
+
+
+def _index_java(source: str, *, rel: str) -> list[Symbol]:
+    return list(
+        JavaIndexer()
+        .index_file(
+            Path(f"/tmp/{rel}"),
+            source.encode("utf-8"),
+            IndexContext(
+                project_root=Path("/tmp"),
+                relative_path=PurePosixPath(rel),
+                language="java",
+            ),
+        )
+        .symbols
+    )
+
+
+def _index_xml(source: bytes, *, rel: str) -> list[Symbol]:
+    return list(
+        MyBatisIndexer()
+        .index_file(
+            Path(f"/tmp/{rel}"),
+            source,
+            IndexContext(
+                project_root=Path("/tmp"),
+                relative_path=PurePosixPath(rel),
+                language="mybatis",
+            ),
+        )
+        .symbols
+    )
+
+
+def _has_maps_to(edges, src_simple: str, tgt_simple: str) -> bool:
+    return any(
+        e.kind == "maps_to"
+        and e.source.descriptors[-1].name == src_simple
+        and e.target.descriptors[-1].name == tgt_simple
+        for e in edges
+    )
+
+
+# ---------------------------------------------------------------------------
+
+
+def test_bridge_metadata() -> None:
+    b = MyBatisLinkBridge()
+    assert b.name == "mybatis_link"
+
+
+def test_maps_java_method_to_sql_mapping() -> None:
+    java = _index_java(
+        """
+        package com.example;
+        public interface CouponMapper {
+            int selectByUser(long userId);
+        }
+        """,
+        rel="src/com/example/CouponMapper.java",
+    )
+    xml = _index_xml(
+        b"""<?xml version='1.0'?>
+        <mapper namespace="com.example.CouponMapper">
+            <select id="selectByUser" resultType="x">SELECT * FROM sf_coupon</select>
+        </mapper>""",
+        rel="src/mapper/CouponMapper.xml",
+    )
+    result = MyBatisLinkBridge().resolve(_StubStore(java + xml))
+    assert _has_maps_to(result.edges, "selectByUser", "selectByUser")
+    assert all(e.confidence == "medium" for e in result.edges if e.kind == "maps_to")
+
+
+def test_no_match_when_namespace_unknown() -> None:
+    """Mapper XML points at a namespace that isn't indexed → no edge."""
+    xml = _index_xml(
+        b"""<?xml version='1.0'?>
+        <mapper namespace="com.example.NotIndexedMapper">
+            <select id="x">SELECT * FROM t</select>
+        </mapper>""",
+        rel="src/mapper/x.xml",
+    )
+    result = MyBatisLinkBridge().resolve(_StubStore(xml))
+    assert result.edges == []
+
+
+def test_method_name_must_match_exactly() -> None:
+    java = _index_java(
+        """
+        package com.example;
+        public interface M {
+            int findOne(long id);
+        }
+        """,
+        rel="src/com/example/M.java",
+    )
+    xml = _index_xml(
+        b"""<?xml version='1.0'?>
+        <mapper namespace="com.example.M">
+            <select id="findTwo">SELECT * FROM t</select>
+        </mapper>""",
+        rel="src/mapper/M.xml",
+    )
+    result = MyBatisLinkBridge().resolve(_StubStore(java + xml))
+    assert result.edges == []

codemap_mybatis-0.3.0/tests/test_sql_tables.py

@@ -0,0 +1,56 @@
+"""Tests for DML table-reference extraction."""
+
+from __future__ import annotations
+
+from codemap_mybatis.sql_tables import table_refs
+
+
+def test_simple_select_from() -> None:
+    refs = table_refs("SELECT * FROM sf_coupon")
+    assert ("sf_coupon", "read") in refs
+
+
+def test_join_marks_as_read() -> None:
+    refs = table_refs("SELECT * FROM sf_coupon c JOIN sf_user u ON c.uid = u.id")
+    assert ("sf_coupon", "read") in refs
+    assert ("sf_user", "read") in refs
+
+
+def test_insert_into_marks_write() -> None:
+    assert ("sf_coupon", "write") in table_refs("INSERT INTO sf_coupon (a) VALUES (1)")
+
+
+def test_update_marks_write() -> None:
+    assert ("sf_coupon", "write") in table_refs("UPDATE sf_coupon SET n = 1 WHERE id = 2")
+
+
+def test_delete_marks_write() -> None:
+    assert ("sf_coupon", "write") in table_refs("DELETE FROM sf_coupon WHERE id = 1")
+
+
+def test_backticked_identifier_cleaned() -> None:
+    refs = table_refs("SELECT * FROM `sf_coupon`")
+    assert ("sf_coupon", "read") in refs
+
+
+def test_qualified_identifier_kept() -> None:
+    refs = table_refs("SELECT * FROM mydb.sf_coupon")
+    # Qualified name preserved as-is; downstream consumers decide normalisation.
+    assert any(r[0].endswith("sf_coupon") for r in refs)
+
+
+def test_case_insensitive_verbs() -> None:
+    assert ("sf_x", "read") in table_refs("select * from sf_x")
+    assert ("sf_x", "write") in table_refs("update sf_x set a=1")
+
+
+def test_no_dml_returns_empty() -> None:
+    assert table_refs("CREATE TABLE x (id int)") == []
+    assert table_refs("") == []
+
+
+def test_write_dominates_over_read_for_same_table() -> None:
+    refs = table_refs("INSERT INTO sf_coupon SELECT * FROM sf_coupon")
+    # write comes first so it dominates; the same (name, access) pair isn't
+    # duplicated, but both access modes can coexist for the same name.
+    assert ("sf_coupon", "write") in refs