codemap-scala 0.1.0a1__py3-none-any.whl

codemap_scala/__init__.py

@@ -0,0 +1,8 @@
+"""Scala indexer plugin for CodeMap."""
+
+from __future__ import annotations
+
+from codemap_scala.indexer import ScalaIndexer
+
+__all__ = ["ScalaIndexer"]
+__version__ = "0.1.0"

codemap_scala/indexer.py

@@ -0,0 +1,287 @@
+"""Scala indexer built on tree-sitter-scala.
+
+A leading ``package_clause`` (or multiple, for nested-package syntax)
+prefixes every symbol with namespace descriptors. Classes / objects /
+traits expose their template body so nested ``def`` / ``val`` / ``var``
+members become methods/fields of the enclosing type.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path, PurePosixPath
+from typing import ClassVar
+
+import tree_sitter
+import tree_sitter_scala
+
+from codemap.core.models import Diagnostic, Edge, IndexResult, Range, Symbol
+from codemap.core.symbol import Descriptor, DescriptorKind, SymbolID
+from codemap.indexers.base import IndexContext
+
+SCHEME = "scip-scala"
+LANG = "scala"
+
+_SCALA_LANG = tree_sitter.Language(tree_sitter_scala.language())
+
+
+class ScalaIndexer:
+    name: ClassVar[str] = "scala"
+    version: ClassVar[str] = "0.1.0"
+    file_patterns: ClassVar[list[str]] = ["*.scala", "*.sc"]
+    languages: ClassVar[list[str]] = [LANG]
+
+    def supports(self, path: Path) -> bool:
+        return path.suffix in {".scala", ".sc"}
+
+    def index_file(
+        self,
+        path: Path,
+        source: bytes,
+        ctx: IndexContext,
+    ) -> IndexResult:
+        try:
+            source.decode("utf-8")
+        except UnicodeDecodeError as exc:
+            return IndexResult(
+                diagnostics=[
+                    Diagnostic(
+                        severity="error",
+                        file=ctx.relative_path,
+                        code="SCALA002",
+                        message=f"not valid UTF-8: {exc}",
+                        producer=self.name,
+                    )
+                ]
+            )
+        parser = tree_sitter.Parser(_SCALA_LANG)
+        tree = parser.parse(source)
+        visitor = _Visitor(ctx.relative_path)
+        visitor.visit_root(tree.root_node)
+        diagnostics = list(visitor.diagnostics)
+        if tree.root_node.has_error:
+            diagnostics.append(
+                Diagnostic(
+                    severity="warning",
+                    file=ctx.relative_path,
+                    range=Range(start_line=1, end_line=1),
+                    code="SCALA001",
+                    message="tree-sitter reported parse errors; symbols may be incomplete",
+                    producer=self.name,
+                )
+            )
+        return IndexResult(
+            symbols=visitor.symbols,
+            edges=visitor.edges,
+            diagnostics=diagnostics,
+        )
+
+
+class _Visitor:
+    def __init__(self, relative_path: PurePosixPath) -> None:
+        self.relative_path = relative_path
+        self.symbols: list[Symbol] = []
+        self.edges: list[Edge] = []
+        self.diagnostics: list[Diagnostic] = []
+
+    def visit_root(self, root: tree_sitter.Node) -> None:
+        scope: list[Descriptor] = []
+        for child in root.children:
+            kind = child.type
+            if kind == "package_clause":
+                scope.extend(
+                    Descriptor(name=part, kind=DescriptorKind.NAMESPACE)
+                    for part in _package_parts(child)
+                )
+            else:
+                self._visit(child, scope=scope)
+
+    def _visit(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        kind = node.type
+        if kind == "class_definition":
+            scala_kind = "case_class" if _is_case(node) else "class"
+            self._emit_type(node, scope=scope, scala_kind=scala_kind)
+        elif kind == "object_definition":
+            scala_kind = "case_object" if _is_case(node) else "object"
+            self._emit_type(node, scope=scope, scala_kind=scala_kind)
+        elif kind == "trait_definition":
+            self._emit_type(node, scope=scope, scala_kind="trait")
+        elif kind == "type_definition":
+            self._emit_type_alias(node, scope=scope)
+        elif kind in {"function_definition", "function_declaration"}:
+            self._emit_method(node, scope=scope)
+        elif kind == "val_definition":
+            self._emit_value(node, scope=scope, scala_kind="val")
+        elif kind == "var_definition":
+            self._emit_value(node, scope=scope, scala_kind="var")
+
+    def _emit_type(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+        scala_kind: str,
+    ) -> None:
+        name = _first_child_text(node, "identifier")
+        if name is None:
+            return
+        type_desc = Descriptor(name=name, kind=DescriptorKind.TYPE)
+        descriptors = [*list(scope), type_desc]
+        self.symbols.append(
+            Symbol(
+                id=self._make_id(descriptors),
+                kind="class",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"scala_kind": scala_kind},
+            )
+        )
+        # Case-class constructor parameters become fields.
+        if scala_kind == "case_class":
+            params = _first_child(node, "class_parameters")
+            if params is not None:
+                for child in params.children:
+                    if child.type == "class_parameter":
+                        pname = _first_child_text(child, "identifier")
+                        if pname is None:
+                            continue
+                        self.symbols.append(
+                            Symbol(
+                                id=self._make_id(
+                                    [
+                                        *list(descriptors),
+                                        Descriptor(name=pname, kind=DescriptorKind.TERM),
+                                    ]
+                                ),
+                                kind="field",
+                                language=LANG,
+                                file=self.relative_path,
+                                range=_node_range(child),
+                                extra={"scala_kind": "case_field"},
+                            )
+                        )
+        # Walk the template body for nested members.
+        body = _first_child(node, "template_body")
+        if body is None:
+            return
+        for child in body.children:
+            self._visit(child, scope=descriptors)
+
+    def _emit_type_alias(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        name = _first_child_text(node, "type_identifier")
+        if name is None:
+            return
+        self.symbols.append(
+            Symbol(
+                id=self._make_id([*list(scope), Descriptor(name=name, kind=DescriptorKind.TYPE)]),
+                kind="class",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"scala_kind": "type"},
+            )
+        )
+
+    def _emit_method(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+    ) -> None:
+        name = _first_child_text(node, "identifier")
+        if name is None:
+            return
+        self.symbols.append(
+            Symbol(
+                id=self._make_id([*list(scope), Descriptor(name=name, kind=DescriptorKind.METHOD)]),
+                kind="method",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                signature=f"{name}()",
+            )
+        )
+
+    def _emit_value(
+        self,
+        node: tree_sitter.Node,
+        *,
+        scope: list[Descriptor],
+        scala_kind: str,
+    ) -> None:
+        name = _first_child_text(node, "identifier")
+        if name is None:
+            return
+        self.symbols.append(
+            Symbol(
+                id=self._make_id([*list(scope), Descriptor(name=name, kind=DescriptorKind.TERM)]),
+                kind="field",
+                language=LANG,
+                file=self.relative_path,
+                range=_node_range(node),
+                extra={"scala_kind": scala_kind},
+            )
+        )
+
+    def _make_id(self, descriptors: list[Descriptor]) -> SymbolID:
+        full = list(_path_namespaces(self.relative_path))
+        full.extend(descriptors)
+        return SymbolID(scheme=SCHEME, descriptors=tuple(full))
+
+
+# ---------------------------------------------------------------------------
+# Pure helpers
+# ---------------------------------------------------------------------------
+
+
+def _path_namespaces(path: PurePosixPath) -> list[Descriptor]:
+    return [Descriptor(name=part, kind=DescriptorKind.NAMESPACE) for part in path.parts]
+
+
+def _node_range(node: tree_sitter.Node) -> Range:
+    sr, sc = node.start_point
+    er, ec = node.end_point
+    return Range(
+        start_line=sr + 1,
+        start_col=sc,
+        end_line=max(er + 1, sr + 1),
+        end_col=ec,
+    )
+
+
+def _node_text(node: tree_sitter.Node) -> str:
+    return node.text.decode("utf-8") if node.text is not None else ""
+
+
+def _first_child(node: tree_sitter.Node, kind: str) -> tree_sitter.Node | None:
+    for child in node.children:
+        if child.type == kind:
+            return child
+    return None
+
+
+def _first_child_text(node: tree_sitter.Node, kind: str) -> str | None:
+    found = _first_child(node, kind)
+    return _node_text(found) if found is not None else None
+
+
+def _is_case(node: tree_sitter.Node) -> bool:
+    return any(child.type == "case" for child in node.children)
+
+
+def _package_parts(node: tree_sitter.Node) -> list[str]:
+    ident_node = _first_child(node, "package_identifier")
+    if ident_node is None:
+        # Fallback: single identifier under package_clause.
+        return [_node_text(c) for c in node.children if c.type == "identifier"]
+    return [_node_text(c) for c in ident_node.children if c.type == "identifier"]

codemap_scala-0.1.0a1.dist-info/METADATA

@@ -0,0 +1,61 @@
+Metadata-Version: 2.4
+Name: codemap-scala
+Version: 0.1.0a1
+Summary: Scala language indexer plugin for CodeMap
+Project-URL: Homepage, https://github.com/qxbyte/codemap
+Author: CodeMap Contributors
+License: MIT
+Keywords: codemap,indexer,scala,tree-sitter
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development
+Requires-Python: >=3.11
+Requires-Dist: codemap-core<0.2,>=0.1.0a1
+Requires-Dist: tree-sitter-scala>=0.23
+Requires-Dist: tree-sitter>=0.25
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# codemap-scala
+
+> A Scala language indexer for [CodeMap](https://github.com/qxbyte/codemap),
+> shipped as an independent PyPI package.
+
+## What it captures
+
+Backed by `tree-sitter-scala`:
+
+| AST node | Symbol kind |
+|---|---|
+| `package_clause` (incl. `package_identifier`) | namespace prefix |
+| `class_definition` (incl. `case class`) | `class` (`extra.scala_kind=class` / `case_class`) |
+| `object_definition` (incl. `case object`) | `class` (`extra.scala_kind=object`) |
+| `trait_definition` | `class` (`extra.scala_kind=trait`) |
+| `type_definition` (top-level alias) | `class` (`extra.scala_kind=type`) |
+| `function_definition` / `function_declaration` | `method` |
+| `val_definition` (top-level or in template body) | `field` (`extra.scala_kind=val`) |
+| `var_definition` (top-level or in template body) | `field` (`extra.scala_kind=var`) |
+| `class_parameter` (in `case class`) | `field` (`extra.scala_kind=case_field`) |
+
+## Install
+
+```bash
+pip install "git+https://github.com/qxbyte/codemap.git#subdirectory=plugins/codemap-scala"
+```
+
+## File patterns
+
+* `*.scala`, `*.sc`
+
+## Limits
+
+* Implicits and Scala 3 `given` declarations parse but are not specifically
+  tagged.
+* Anonymous classes (`new T { ... }`) are not surfaced.
+* Block-scoped `def` inside a method body is not emitted — it is private
+  to that method.
+
+## License
+
+MIT.

codemap_scala-0.1.0a1.dist-info/RECORD

@@ -0,0 +1,6 @@
+codemap_scala/__init__.py,sha256=ch-EJxrOJh7cknEErFgjqNrcM50VL30h8--xEkkUaCQ,174
+codemap_scala/indexer.py,sha256=1sV7AfaYEOKV3COYyZTV_gAYnKY-rz6VnwDVhwI45KM,9806
+codemap_scala-0.1.0a1.dist-info/METADATA,sha256=PryUPRvSkBAQ6Y1Vmh_QcLeNOSulSOCdTlsxqWKJ0pk,1981
+codemap_scala-0.1.0a1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+codemap_scala-0.1.0a1.dist-info/entry_points.txt,sha256=rkUKL5rkDgkwk3sFmuk7cXdxk5FhF0jNUMt8bSLAjOo,54
+codemap_scala-0.1.0a1.dist-info/RECORD,,

codemap_scala-0.1.0a1.dist-info/WHEEL

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

codemap_scala-0.1.0a1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[codemap.indexers]
+scala = codemap_scala:ScalaIndexer