codemap-mybatis 0.3.0__py3-none-any.whl

codemap_mybatis/__init__.py

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

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/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/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.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,8 @@
+codemap_mybatis/__init__.py,sha256=VKGyJK3oxRWguXqGno6yLzZCAY50BJAtV_cHB7pwTGQ,123
+codemap_mybatis/indexer.py,sha256=fdAzytr4tQ_wq9fjbi6yWBVVL-zdOCbdvJnTpUR2HSI,6738
+codemap_mybatis/link.py,sha256=sJF75pdwvg2iwb1TEaiBwejZ-sEPEnGAVXzDIYNq_iA,3608
+codemap_mybatis/sql_tables.py,sha256=ZKXvEqdOmwID4ySBmxXAWIljNGGchisl5vv8EDmZzg0,1944
+codemap_mybatis-0.3.0.dist-info/METADATA,sha256=3_TF8oH1w_v5Tb0VE1hZ-yOPmHGsCeMbidQQ0kiawZ0,1691
+codemap_mybatis-0.3.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+codemap_mybatis-0.3.0.dist-info/entry_points.txt,sha256=XojIYn2AsNgKee1sQtURK4MsOJMxwxLt60it5ptEpQ0,133
+codemap_mybatis-0.3.0.dist-info/RECORD,,

codemap_mybatis-0.3.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

codemap_mybatis-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,5 @@
+[codemap.bridges]
+mybatis_link = codemap_mybatis.link:MyBatisLinkBridge
+
+[codemap.indexers]
+mybatis = codemap_mybatis:MyBatisIndexer