rbtr-lang-rust 2026.9.0.dev1__tar.gz

rbtr_lang_rust-2026.9.0.dev1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alejandro Giacometti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

rbtr_lang_rust-2026.9.0.dev1/PKG-INFO

@@ -0,0 +1,67 @@
+Metadata-Version: 2.4
+Name: rbtr-lang-rust
+Version: 2026.9.0.dev1
+Summary: rbtr — Rust language plugin
+Keywords: code-search,code-index,tree-sitter,static-analysis,semantic-search,developer-tools,rust
+Author: Alejandro Giacometti
+Author-email: Alejandro Giacometti <alejandro.giacometti@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Rust
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Typing :: Typed
+Requires-Dist: rbtr==2026.9.0.dev1
+Requires-Dist: tree-sitter-rust
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/janrito/rbtr
+Project-URL: Repository, https://github.com/janrito/rbtr
+Project-URL: Documentation, https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-rust#readme
+Project-URL: Issues, https://github.com/janrito/rbtr/issues
+Project-URL: Changelog, https://github.com/janrito/rbtr/releases
+Description-Content-Type: text/markdown
+
+# rbtr-lang-rust
+
+Rust support for [rbtr]. Optional plugin — install with
+`pip install rbtr[rust]`.
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+
+## What it ingests
+
+- **Functions & methods** — `fn`; functions inside an `impl` are methods
+  scoped to the type.
+- **Classes** — `struct`, `enum`, `trait`, and `impl` blocks (an `impl Svc`
+  and `struct Svc` both yield a `Svc` class chunk).
+- **Variables** — module-level `const` / `static`.
+- **Imports** — `use` declarations (scoped paths resolved), for cross-file
+  edges.
+- **Attributes** — `#[derive(...)]`, `#[serde(...)]` and the rest fold into
+  the item below them, so a type is findable by the traits it derives. A
+  module-level `#![allow(...)]`, with no item under it, is its own chunk.
+
+Leading `///` / `//!` doc comments fold into the symbol's content, together
+with any attribute between the comment and the item.
+
+## Chunks produced
+
+```rust
+fn greet(name: &str) -> String { … }   // function "greet"
+struct Server { … }                    // class "Server"
+impl Server { fn start(&self) {} }     // class "Server"; method "start", scope "Server"
+const MAX: u32 = 100;                  // variable "MAX"
+use crate::config::Config;             // import, metadata {module: crate::config::Config}
+```
+
+## Embedded / injected chunks
+
+None. Rust does not embed other languages.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-rust` grammar. No dependency on other language plugins.

rbtr_lang_rust-2026.9.0.dev1/README.md

@@ -0,0 +1,40 @@
+# rbtr-lang-rust
+
+Rust support for [rbtr]. Optional plugin — install with
+`pip install rbtr[rust]`.
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+
+## What it ingests
+
+- **Functions & methods** — `fn`; functions inside an `impl` are methods
+  scoped to the type.
+- **Classes** — `struct`, `enum`, `trait`, and `impl` blocks (an `impl Svc`
+  and `struct Svc` both yield a `Svc` class chunk).
+- **Variables** — module-level `const` / `static`.
+- **Imports** — `use` declarations (scoped paths resolved), for cross-file
+  edges.
+- **Attributes** — `#[derive(...)]`, `#[serde(...)]` and the rest fold into
+  the item below them, so a type is findable by the traits it derives. A
+  module-level `#![allow(...)]`, with no item under it, is its own chunk.
+
+Leading `///` / `//!` doc comments fold into the symbol's content, together
+with any attribute between the comment and the item.
+
+## Chunks produced
+
+```rust
+fn greet(name: &str) -> String { … }   // function "greet"
+struct Server { … }                    // class "Server"
+impl Server { fn start(&self) {} }     // class "Server"; method "start", scope "Server"
+const MAX: u32 = 100;                  // variable "MAX"
+use crate::config::Config;             // import, metadata {module: crate::config::Config}
+```
+
+## Embedded / injected chunks
+
+None. Rust does not embed other languages.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-rust` grammar. No dependency on other language plugins.

rbtr_lang_rust-2026.9.0.dev1/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["uv_build>=0.11.26,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "rbtr_lang_rust"
+
+[tool.uv.sources.rbtr]
+workspace = true
+
+[project]
+name = "rbtr-lang-rust"
+version = "2026.9.0-dev1"
+description = "rbtr — Rust language plugin"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "code-search",
+    "code-index",
+    "tree-sitter",
+    "static-analysis",
+    "semantic-search",
+    "developer-tools",
+    "rust",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Rust",
+    "Topic :: Software Development :: Libraries",
+    "Topic :: Text Processing :: Indexing",
+    "Typing :: Typed",
+]
+requires-python = ">=3.13"
+dependencies = [
+    "rbtr==2026.9.0-dev1",
+    "tree-sitter-rust",
+]
+
+[[project.authors]]
+name = "Alejandro Giacometti"
+email = "alejandro.giacometti@gmail.com"
+
+[project.urls]
+Homepage = "https://github.com/janrito/rbtr"
+Repository = "https://github.com/janrito/rbtr"
+Documentation = "https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-rust#readme"
+Issues = "https://github.com/janrito/rbtr/issues"
+Changelog = "https://github.com/janrito/rbtr/releases"
+
+[project.entry-points."rbtr.languages"]
+rust = "rbtr_lang_rust.plugin:rust"
+
+[dependency-groups]
+dev = ["rbtr[test]"]

rbtr_lang_rust-2026.9.0.dev1/pyproject.toml.orig

@@ -0,0 +1,62 @@
+[build-system]
+requires = ["uv_build>=0.11.26,<1"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+module-name = "rbtr_lang_rust"
+# No source-exclude: the plugin's tests, samples, and snapshots ship with
+# the wheel (they are the language's golden record), and rust.scm ships as
+# package data.
+
+[project]
+name = "rbtr-lang-rust"
+version = "2026.9.0-dev1"
+description = "rbtr — Rust language plugin"
+readme = "README.md"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "Alejandro Giacometti", email = "alejandro.giacometti@gmail.com" },
+]
+keywords = [
+  "code-search",
+  "code-index",
+  "tree-sitter",
+  "static-analysis",
+  "semantic-search",
+  "developer-tools",
+  "rust",
+]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3 :: Only",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Rust",
+  "Topic :: Software Development :: Libraries",
+  "Topic :: Text Processing :: Indexing",
+  "Typing :: Typed",
+]
+requires-python = ">=3.13"
+dependencies = [
+  "rbtr==2026.9.0-dev1",
+  "tree-sitter-rust",
+]
+
+[project.urls]
+Homepage = "https://github.com/janrito/rbtr"
+Repository = "https://github.com/janrito/rbtr"
+Documentation = "https://github.com/janrito/rbtr/tree/main/packages/rbtr-lang-rust#readme"
+Issues = "https://github.com/janrito/rbtr/issues"
+Changelog = "https://github.com/janrito/rbtr/releases"
+
+[project.entry-points."rbtr.languages"]
+# The value resolves to the language's `LanguageRegistration` (named by its
+# id) — see the rbtr ARCHITECTURE "External plugins" note.
+rust = "rbtr_lang_rust.plugin:rust"
+
+[tool.uv.sources]
+rbtr = { workspace = true }
+
+[dependency-groups]
+dev = ["rbtr[test]"]

rbtr_lang_rust-2026.9.0.dev1/src/rbtr_lang_rust/__init__.py

@@ -0,0 +1 @@
+"""Rust language plugin package."""

rbtr_lang_rust-2026.9.0.dev1/src/rbtr_lang_rust/plugin.py

@@ -0,0 +1,147 @@
+"""Rust language plugin.
+
+Provides full support: functions, structs, enums, unions, type
+aliases, traits, modules, impl blocks, `macro_rules!` definitions,
+and `use` declaration extraction. Traits, modules, and impl blocks
+form naming scopes; trait and impl members are methods.
+
+Extracted chunks::
+
+    fn hello() {}                   → function "hello", scope ""
+    struct User { name: String }    → class "User", scope ""
+    enum Color { Red, Green }       → class "Color", scope ""
+    impl Svc {
+        fn start(&self) {}          → method "start", scope "Svc"
+    }
+
+    use std::collections::HashMap
+        → import, metadata {module: "std/collections", names: "HashMap"}
+    use crate::models::{Chunk, Edge}
+        → import, metadata {module: "crate/models", names: "Chunk,Edge"}
+    use super::utils
+        → import, metadata {names: "utils", dots: "2"}
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rbtr.domain.models import ImportMeta
+from rbtr.languages.registration import (
+    ImportResolver,
+    LanguageRegistration,
+    QueryExtraction,
+    collect_scoped_path,
+    load_query,
+)
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+# ── Query ────────────────────────────────────────────────────────────
+
+
+# ── Import extractor ─────────────────────────────────────────────────
+
+
+def _path_to_meta(parts: list[str], meta: ImportMeta) -> None:
+    """Convert collected Rust path segments into module/dots metadata.
+
+    Leading `super` segments are counted as relative dots using
+    the unified convention (each `super` = one extra level up,
+    plus 1 for the file itself).  `crate` is kept as a literal
+    path segment — it's root-relative, not parent-relative.
+    """
+    dots = 0
+    while parts and parts[0] == "super":
+        dots += 1
+        parts = parts[1:]
+    if dots:
+        meta.dots = str(dots + 1)  # +1: super = parent dir = 2 levels from file
+
+    if parts:
+        meta.module = "/".join(parts)
+
+
+def extract_import_meta(
+    _resolver: ImportResolver, node: Node, captures: dict[str, list[Node]]
+) -> ImportMeta:
+    """Extract import data from a Rust `use_declaration` node.
+
+    Walks the node's `argument` field for module path and names.
+    The query only captures `@import` — module extraction needs
+    `collect_scoped_path` to flatten `scoped_identifier` trees
+    and `_path_to_meta` to convert `super` segments to dots.
+
+    Examples:
+
+        `use std::collections::HashMap;`:
+            module="std/collections", names="HashMap"
+
+        `use crate::models::{Chunk, Edge};`:
+            module="crate/models", names="Chunk,Edge"
+
+        `use super::utils;`:
+            names="utils", dots="2"
+
+        `use std::io::{self, Read};`:
+            module="std/io", names="self,Read"
+
+        `use serde;`:
+            module="serde"
+    """
+    meta = ImportMeta()
+    arg = node.child_by_field_name("argument")
+    if arg is None:
+        return meta
+
+    match arg.type:
+        case "scoped_identifier":
+            parts = collect_scoped_path(arg)
+            if len(parts) > 1:
+                _path_to_meta(parts[:-1], meta)
+                meta.names = parts[-1]
+            elif parts:
+                _path_to_meta(parts, meta)
+
+        case "scoped_use_list":
+            path_parts: list[str] = []
+            names: list[str] = []
+            for sc in arg.children:
+                if sc.type == "scoped_identifier":
+                    path_parts = collect_scoped_path(sc)
+                elif sc.type == "use_list":
+                    for item in sc.children:
+                        if item.type == "identifier" and item.text:
+                            names.append(item.text.decode())
+                        elif item.type == "self":
+                            names.append("self")
+            _path_to_meta(path_parts, meta)
+            if names:
+                meta.names = ",".join(names)
+
+        case "identifier":
+            if arg.text:
+                meta.module = arg.text.decode()
+
+    return meta
+
+
+# ── Plugin ───────────────────────────────────────────────────────────
+
+
+rust = LanguageRegistration(
+    id="rust",
+    extensions=frozenset({".rs"}),
+    grammar_module="tree_sitter_rust",
+    extraction=QueryExtraction(
+        query=load_query(__package__, "rust"),
+        scope_types=frozenset({"impl_item", "struct_item", "trait_item", "mod_item", "enum_item"}),
+        class_scope_types=frozenset({"impl_item", "struct_item", "trait_item"}),
+    ),
+    index_files=frozenset({"mod.rs"}),
+    path_substitutions=(("crate/", "src/"),),
+    extraction_serial=6,
+)
+
+rust.import_extractor(extract_import_meta)

rbtr_lang_rust-2026.9.0.dev1/src/rbtr_lang_rust/rust.scm

@@ -0,0 +1,52 @@
+; Comments (Rust: `//`/`///`/`//!` line and `/* */` block).
+[(line_comment) (block_comment)] @comment
+
+; An attribute documents the item below it and is its sibling in the
+; tree, so it folds into that item exactly as a comment block does. One
+; standing alone — a module's `#![allow(...)]` — becomes its own chunk.
+(source_file [(attribute_item) (inner_attribute_item)] @comment)
+
+(function_item
+  name: (identifier) @_fn_name) @function
+
+(function_signature_item
+  name: (identifier) @_fn_name) @function
+
+(struct_item
+  name: (type_identifier) @_cls_name) @class
+
+(enum_item
+  name: (type_identifier) @_cls_name) @class
+
+(enum_item
+  body: (enum_variant_list
+    (enum_variant
+      name: (identifier) @_var_name) @variable))
+
+(union_item
+  name: (type_identifier) @_cls_name) @class
+
+(type_item
+  name: (type_identifier) @_cls_name) @class
+
+(trait_item
+  name: (type_identifier) @_cls_name) @class
+
+(mod_item
+  name: (identifier) @_cls_name) @class
+
+(macro_definition
+  name: (identifier) @_fn_name) @function
+
+(impl_item
+  type: (type_identifier) @_cls_name) @class
+
+(use_declaration) @import
+
+(source_file
+  (const_item
+    name: (identifier) @_var_name) @variable)
+
+(source_file
+  (static_item
+    name: (identifier) @_var_name) @variable)

rbtr_lang_rust-2026.9.0.dev1/src/rbtr_lang_rust/tests/__snapshots__/test_samples/test_edges_match_snapshot.json

@@ -0,0 +1,3 @@
+[
+  "rust.rs::use crate::config::LOCALE; -> src/config.rs::LOCALE [imports]"
+]