rbtr-lang-ruby 2026.9.0.dev0__py3-none-any.whl

rbtr_lang_ruby/__init__.py

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

rbtr_lang_ruby/plugin.py

@@ -0,0 +1,97 @@
+"""Ruby language plugin.
+
+Provides symbol extraction (methods, classes, modules, constants,
+and the RSpec `describe`/`context`/`it` DSL) and structured import
+metadata from `require` / `require_relative`.  Constants scope to
+their enclosing class/module.  RSpec groups (`describe`/`context`/
+`feature`) are classes and examples (`it`/`specify`/`example`) are
+functions, named by their description string.
+
+Extracted chunks::
+
+    def greet ... end               → function "greet", scope ""
+    class Shape ... end             → class "Shape", scope ""
+    module Utils ... end            → class "Utils", scope ""
+    class Foo
+      def bar ... end               → method "bar", scope "Foo"
+    end
+
+    require "json"
+        → import, metadata {module: "json"}
+    require_relative "helpers"
+        → import, metadata {module: "helpers", dots: "1"}
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rbtr.domain.models import ImportMeta
+from rbtr.languages.registration import (
+    ImportResolver,
+    LanguageRegistration,
+    QueryExtraction,
+    load_query,
+    parse_path_relative,
+)
+
+if TYPE_CHECKING:
+    from tree_sitter import Node
+
+# ── Query ────────────────────────────────────────────────────────────
+
+
+# ── Import extractor ─────────────────────────────────────────────────
+
+
+def extract_import_meta(
+    resolver: ImportResolver, node: Node, captures: dict[str, list[Node]]
+) -> ImportMeta:
+    """Extract import data from a Ruby `require` / `require_relative` node.
+
+    Reads `@_import_module` from captures (the query captures
+    the string argument), then sets `dots` for
+    `require_relative` (always relative to the current file).
+
+    Examples:
+
+        `require "json"`:
+            module="json"
+
+        `require_relative "helpers"`:
+            module="helpers", dots="1"
+
+        `require_relative "./config"`:
+            module="config", dots="1"
+
+        `require_relative "../lib/utils"`:
+            module="lib/utils", dots="2"
+    """
+    meta = resolver(node, captures)
+    method = node.child_by_field_name("method")
+    if method and method.text == b"require_relative":
+        # `require_relative` is always relative to the current file. Strip any
+        # `./`/`../` prefix into `dots` (a bare path is the current dir, dots=1)
+        # so the resolver doesn't see a leftover `./` it can't match.
+        dots, cleaned = parse_path_relative(meta.module)
+        meta.module = cleaned
+        meta.dots = str(dots or 1)
+    return meta
+
+
+# ── Plugin ───────────────────────────────────────────────────────────
+
+
+ruby = LanguageRegistration(
+    id="ruby",
+    extensions=frozenset({".rb"}),
+    grammar_module="tree_sitter_ruby",
+    extraction=QueryExtraction(
+        query=load_query(__package__, "ruby"),
+        scope_types=frozenset({"class", "module"}),
+    ),
+    source_roots=("", "lib"),
+    extraction_serial=5,
+)
+
+ruby.import_extractor(extract_import_meta)

rbtr_lang_ruby/ruby.scm

@@ -0,0 +1,51 @@
+
+; Comments (Ruby: `#` line and `=begin`/`=end` block, both `comment`).
+(comment) @comment
+
+(method
+  name: (identifier) @_fn_name) @function
+
+(singleton_method
+  name: (identifier) @_fn_name) @function
+
+(class
+  name: (constant) @_cls_name) @class
+
+(module
+  name: (constant) @_cls_name) @class
+
+(call
+  method: (identifier) @_call_name
+  arguments: (argument_list
+    (string) @_import_module)
+  (#eq? @_call_name "require"))  @import
+
+(call
+  method: (identifier) @_call_name
+  arguments: (argument_list
+    (string) @_import_module)
+  (#eq? @_call_name "require_relative"))  @import
+
+(assignment
+  left: (constant) @_var_name) @variable
+
+(assignment
+  left: (left_assignment_list (constant) @_var_name)) @variable
+
+(assignment
+  left: (left_assignment_list (rest_assignment (constant) @_var_name))) @variable
+
+(call
+  method: (identifier) @_call_name
+  arguments: (argument_list . (string (string_content) @_cls_name))
+  (#any-of? @_call_name "describe" "context" "feature" "shared_examples" "shared_context")) @class
+
+(call
+  method: (identifier) @_call_name
+  arguments: (argument_list . (constant) @_cls_name)
+  (#any-of? @_call_name "describe" "context" "feature")) @class
+
+(call
+  method: (identifier) @_call_name
+  arguments: (argument_list . (string (string_content) @_fn_name))
+  (#any-of? @_call_name "it" "specify" "example" "scenario")) @function

rbtr_lang_ruby/tests/__snapshots__/test_samples/test_edges_match_snapshot.json

@@ -0,0 +1,3 @@
+[
+  "ruby.rb::require_relative \"./config\" -> config.rb::DEFAULT_LOCALE [imports]"
+]

rbtr_lang_ruby/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json

@@ -0,0 +1,382 @@
+[
+  {
+    "blob_sha": "sha1",
+    "file_path": "config.rb",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# frozen_string_literal: true",
+    "line_start": 1,
+    "line_end": 1,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "16e7f0488dd01998"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "config.rb",
+    "kind": "variable",
+    "name": "DEFAULT_LOCALE",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# Greeter configuration.\nDEFAULT_LOCALE = \"en\"",
+    "line_start": 3,
+    "line_end": 4,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "32b6464c28d5298b"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# frozen_string_literal: true",
+    "line_start": 1,
+    "line_end": 1,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "16e7f0488dd01998"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# Greeter — format greetings for named recipients.\n#\n# The Ruby plugin extracts top-level defs (as functions), classes and\n# modules, defs inside them (as methods), constant assignments (as\n# variables, scoped to their class/module), the RSpec describe/it DSL\n# (groups as classes, examples as functions), and require /\n# require_relative imports.",
+    "line_start": 3,
+    "line_end": 9,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "451436cb9495c8e3"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "import",
+    "name": "require \"json\"",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "require \"json\"",
+    "line_start": 11,
+    "line_end": 11,
+    "metadata": {
+      "module": "json",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "55888f95be8c407e"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "import",
+    "name": "require_relative \"./config\"",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "require_relative \"./config\"",
+    "line_start": 12,
+    "line_end": 12,
+    "metadata": {
+      "module": "config",
+      "names": "",
+      "dots": "1",
+      "language_hint": ""
+    },
+    "id": "6f6e733c7294dbdc"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "variable",
+    "name": "DEFAULT_GREETING",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "DEFAULT_GREETING = \"Hello\"",
+    "line_start": 14,
+    "line_end": 14,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "0c28350e9069a2c7"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# trailing comment: its own chunk",
+    "line_start": 14,
+    "line_end": 14,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "ed4ca5590a0f51ed"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "comment",
+    "name": "",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# Standalone note, separated by blank lines from any definition.\n# Second line of the same block.",
+    "line_start": 16,
+    "line_end": 17,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "b9eb0ec1fcda7627"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "class",
+    "name": "Shoutable",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# Mixin providing a shout helper.\nmodule Shoutable\n  def shout(message)\n    message.upcase\n  end\nend",
+    "line_start": 19,
+    "line_end": 24,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "e30c23f14bbed540"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "method",
+    "name": "shout",
+    "scope": "Shoutable",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "def shout(message)\n    message.upcase\n  end",
+    "line_start": 21,
+    "line_end": 23,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "a8d8716691e53686"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "class",
+    "name": "Greeter",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# Formats greetings with a prefix.\nclass Greeter\n  include Shoutable\n\n  MAX_NAME_LENGTH = 64\n\n  def initialize(prefix = DEFAULT_GREETING)\n    @prefix = prefix\n  end\n\n  # Greet a single recipient.\n  def greet(name)\n    \"#{@prefix}, #{name}\"\n  end\n\n  def self.default\n    new(DEFAULT_GREETING)\n  end\nend",
+    "line_start": 26,
+    "line_end": 44,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "1e1f11916c4f30a1"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "variable",
+    "name": "MAX_NAME_LENGTH",
+    "scope": "Greeter",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "MAX_NAME_LENGTH = 64",
+    "line_start": 30,
+    "line_end": 30,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "023bd4450cd467e2"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "method",
+    "name": "initialize",
+    "scope": "Greeter",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "def initialize(prefix = DEFAULT_GREETING)\n    @prefix = prefix\n  end",
+    "line_start": 32,
+    "line_end": 34,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "97a4b17df8cf5cb8"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "method",
+    "name": "greet",
+    "scope": "Greeter",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# Greet a single recipient.\n  def greet(name)\n    \"#{@prefix}, #{name}\"\n  end",
+    "line_start": 36,
+    "line_end": 39,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "50c202645f9e2fc6"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "method",
+    "name": "default",
+    "scope": "Greeter",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "def self.default\n    new(DEFAULT_GREETING)\n  end",
+    "line_start": 41,
+    "line_end": 43,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "e7912cb64a05b9fe"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "function",
+    "name": "format_greeting",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# Top-level helper that builds a greeter and greets.\ndef format_greeting(name)\n  Greeter.new.greet(name)\nend",
+    "line_start": 46,
+    "line_end": 49,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "3f0252c2b63ec688"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "class",
+    "name": "Greeter",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "# RSpec-style specification exercising the describe/it DSL.\nRSpec.describe Greeter do\n  describe \"#greet\" do\n    it \"includes the configured prefix\" do\n      expect(Greeter.new.greet(\"Sam\")).to include(\"Hello\")\n    end\n  end\nend",
+    "line_start": 51,
+    "line_end": 58,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "40e1158328623a05"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "class",
+    "name": "#greet",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "describe \"#greet\" do\n    it \"includes the configured prefix\" do\n      expect(Greeter.new.greet(\"Sam\")).to include(\"Hello\")\n    end\n  end",
+    "line_start": 53,
+    "line_end": 57,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "6557c0dbc5a0d319"
+  },
+  {
+    "blob_sha": "sha1",
+    "file_path": "ruby.rb",
+    "kind": "function",
+    "name": "includes the configured prefix",
+    "scope": "",
+    "language": "ruby",
+    "file_language": "ruby",
+    "content": "it \"includes the configured prefix\" do\n      expect(Greeter.new.greet(\"Sam\")).to include(\"Hello\")\n    end",
+    "line_start": 54,
+    "line_end": 56,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    },
+    "id": "62cc3ae125d0a288"
+  }
+]

rbtr_lang_ruby/tests/cases_docstrings.py

@@ -0,0 +1,126 @@
+"""Ruby docstring-extraction test cases.
+
+Each `@case` returns `(lang, source, symbol_name, snippet)` consumed by `test_docstrings.py`.
+"""
+
+from __future__ import annotations
+
+from pytest_cases import case
+
+type DocstringCase = tuple[str, str, str, str]
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_ruby_hash_doc_on_def() -> DocstringCase:
+    """Canonical `#` comment above a top-level def."""
+    src = """\
+# Greet the user.
+def greet
+  'hi'
+end
+"""
+    return "ruby", src, "greet", "Greet the user"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_ruby_hash_doc_on_class() -> DocstringCase:
+    """`#` comment above a class declaration."""
+    src = """\
+# Service facade.
+class Svc
+end
+"""
+    return "ruby", src, "Svc", "Service facade"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_ruby_hash_doc_on_module() -> DocstringCase:
+    """`#` comment above a module declaration."""
+    src = """\
+# Utilities.
+module Utils
+end
+"""
+    return "ruby", src, "Utils", "Utilities"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_ruby_multi_line_hash_doc() -> DocstringCase:
+    """Multi-line `#` doc comment."""
+    src = """\
+# Compute a checksum.
+#
+# Returns a hex digest string.
+def checksum
+  ''
+end
+"""
+    return "ruby", src, "checksum", "Returns a hex digest"
+
+
+@case(tags=["documented", "edge_case", "exterior_doc"])
+def case_ruby_block_comment_begin_end() -> DocstringCase:
+    """`=begin` / `=end` block comment.  The grammar treats it
+    as a single `comment` node; attachment works when it
+    immediately precedes the `def`.
+    """
+    src = """\
+=begin
+Block-style doc.
+=end
+def foo
+end
+"""
+    return "ruby", src, "foo", "Block-style doc"
+
+
+@case(tags=["documented", "unconventional", "exterior_doc"])
+def case_ruby_shebang_like_comment_above_def() -> DocstringCase:
+    """Unconventional but valid: a `#` run whose first line
+    starts with `#!`-style emphasis still attaches.
+    """
+    src = """\
+#! IMPORTANT: use Foo instead of Bar.
+# Prefer modern API.
+def legacy
+end
+"""
+    return "ruby", src, "legacy", "IMPORTANT: use Foo"
+
+
+@case(tags=["undocumented", "no_docs"])
+def case_ruby_def_without_doc() -> DocstringCase:
+    """Undocumented top-level def."""
+    src = """\
+def bare
+end
+"""
+    return "ruby", src, "bare", "PHANTOM_DOC_TEXT_SHOULD_NEVER_APPEAR"
+
+
+@case(tags=["undocumented", "boundary_not_attached"])
+def case_ruby_doc_detached_by_blank_line() -> DocstringCase:
+    """Blank line between comment and def breaks attachment."""
+    src = """\
+# Orphan.
+
+def later
+end
+"""
+    return "ruby", src, "later", "Orphan"
+
+
+@case(tags=["undocumented", "invalid"])
+def case_ruby_doc_does_not_steal_from_next() -> DocstringCase:
+    """A `#` comment between two top-level defs belongs to the
+    later def, not the earlier one.
+    """
+    src = """\
+def first
+end
+
+# Doc for second.
+def second
+end
+"""
+    return "ruby", src, "first", "Doc for second"

rbtr_lang_ruby/tests/cases_extraction.py

@@ -0,0 +1,320 @@
+"""Ruby extraction test cases."""
+
+from __future__ import annotations
+
+import pytest
+from pytest_cases import case
+
+type SymbolCase = tuple[str, str, list[tuple[str, str, str]]]
+type ImportCase = tuple[str, str, dict[str, str]]
+type MultiImportCase = tuple[str, str, int, list[dict[str, str]]]
+type MixedCase = tuple[str, str, set[str], list[tuple[str, str]]]
+
+_xfail_nested = pytest.mark.xfail(
+    reason="nested/chained destructuring unsupported — no query-only recursion",
+    strict=True,
+)
+
+
+@case(tags=["symbol"])
+def case_ruby_method_no_args() -> SymbolCase:
+    """def greet — top-level function."""
+    src = """\
+def greet
+  puts "hello"
+end
+"""
+    return "ruby", src, [("function", "greet", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_method_with_args() -> SymbolCase:
+    """def add(a, b) — top-level function."""
+    src = """\
+def add(a, b)
+  a + b
+end
+"""
+    return "ruby", src, [("function", "add", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_multiple_functions() -> SymbolCase:
+    """Multiple top-level functions."""
+    src = """\
+def foo
+  1
+end
+
+def bar
+  2
+end
+"""
+    return "ruby", src, [("function", "foo", ""), ("function", "bar", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_class() -> SymbolCase:
+    """class Shape."""
+    src = """\
+class Shape
+end
+"""
+    return "ruby", src, [("class", "Shape", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_module() -> SymbolCase:
+    """module Utils."""
+    src = """\
+module Utils
+end
+"""
+    return "ruby", src, [("class", "Utils", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_class_superclass() -> SymbolCase:
+    """class Circle < Shape."""
+    src = """\
+class Circle < Shape
+end
+"""
+    return "ruby", src, [("class", "Circle", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_method_scoped_to_class() -> SymbolCase:
+    """Method scoped to class."""
+    src = """\
+class Foo
+  def bar
+    1
+  end
+end
+"""
+    return "ruby", src, [("method", "bar", "Foo")]
+
+
+@case(tags=["symbol"])
+def case_ruby_singleton_method() -> SymbolCase:
+    """def self.build — singleton method."""
+    src = """\
+class Factory
+  def self.build
+    new
+  end
+end
+"""
+    return "ruby", src, [("method", "build", "Factory")]
+
+
+@case(tags=["symbol"])
+def case_ruby_method_scoped_to_module() -> SymbolCase:
+    """Method scoped to module."""
+    src = """\
+module Helpers
+  def format(s)
+    s.strip
+  end
+end
+"""
+    return "ruby", src, [("method", "format", "Helpers")]
+
+
+@case(tags=["symbol"])
+def case_ruby_top_level_not_scoped() -> SymbolCase:
+    """Function after class is not scoped."""
+    src = """\
+class C
+end
+
+def standalone
+  1
+end
+"""
+    return "ruby", src, [("function", "standalone", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_nested_class_in_module() -> SymbolCase:
+    """Class nested in module, method scoped to inner class."""
+    src = """\
+module Utils
+  class Parser
+    def parse(input)
+      input
+    end
+  end
+end
+"""
+    return (
+        "ruby",
+        src,
+        [
+            ("class", "Utils", ""),
+            ("class", "Parser", "Utils"),
+            ("method", "parse", "Utils::Parser"),
+        ],
+    )
+
+
+@case(tags=["symbol"])
+def case_ruby_module_in_module() -> SymbolCase:
+    """A method in a module nested in a module carries the full path."""
+    src = """\
+module A
+  module B
+    def f
+      1
+    end
+  end
+end
+"""
+    return "ruby", src, [("method", "f", "A::B")]
+
+
+@case(tags=["symbol"])
+def case_ruby_module_module_class_method() -> SymbolCase:
+    """A method nested module::module::class carries the full path."""
+    src = """\
+module A
+  module B
+    class C
+      def go
+        1
+      end
+    end
+  end
+end
+"""
+    return "ruby", src, [("method", "go", "A::B::C")]
+
+
+@case(tags=["import"])
+def case_ruby_require_simple() -> ImportCase:
+    """require "json"."""
+    return "ruby", 'require "json"\n', {"module": "json"}
+
+
+@case(tags=["import"])
+def case_ruby_require_nested() -> ImportCase:
+    """require "net/http"."""
+    return "ruby", 'require "net/http"\n', {"module": "net/http"}
+
+
+@case(tags=["import"])
+def case_ruby_require_relative() -> ImportCase:
+    """require_relative "helpers"."""
+    return "ruby", 'require_relative "helpers"\n', {"module": "helpers", "dots": "1"}
+
+
+@case(tags=["import"])
+def case_ruby_require_relative_nested() -> ImportCase:
+    """require_relative "lib/utils"."""
+    return "ruby", 'require_relative "lib/utils"\n', {"module": "lib/utils", "dots": "1"}
+
+
+@case(tags=["import"])
+def case_ruby_require_relative_dot_prefix() -> ImportCase:
+    """require_relative "./config" — the `./` is stripped into dots."""
+    return "ruby", 'require_relative "./config"\n', {"module": "config", "dots": "1"}
+
+
+@case(tags=["import"])
+def case_ruby_require_relative_parent() -> ImportCase:
+    """require_relative "../lib/utils" — `../` becomes dots=2."""
+    return "ruby", 'require_relative "../lib/utils"\n', {"module": "lib/utils", "dots": "2"}
+
+
+@case(tags=["import"])
+def case_ruby_require_empty_string() -> ImportCase:
+    """require "" — empty string returns empty metadata.
+
+    Covers `ruby.py` lines 53 and 70.
+    """
+    return "ruby", 'require ""\n', {}
+
+
+@case(tags=["multi_import"])
+def case_ruby_multiple_requires() -> MultiImportCase:
+    """require + require_relative."""
+    src = """\
+require "json"
+require_relative "helpers"
+"""
+    return "ruby", src, 2, [{"module": "json"}, {"module": "helpers", "dots": "1"}]
+
+
+@case(tags=["mixed"])
+def case_ruby_full_file() -> MixedCase:
+    """Realistic Ruby file with doc comments on top-level
+    declarations.  Comments inside the class body are not
+    attached to their methods by the current Ruby grammar (see
+    note in `case_docstrings.py`), so only the top-level
+    module, class, and `main` carry docs here.  Methods carry the
+    full module::class path now that addressing composes the
+    enclosing-scope chain.
+    """
+    src = """\
+require "json"
+require_relative "config"
+
+# Application namespace for the service.
+module App
+  # Server runs the request loop.
+  class Server
+    def start
+      puts "starting"
+    end
+
+    def stop
+      puts "stopping"
+    end
+
+    def self.default
+      new
+    end
+  end
+end
+
+# Entry point used by bin/app.
+def main
+  server = App::Server.new
+  server.start
+end
+"""
+    return (
+        "ruby",
+        src,
+        {"import", "class", "method", "function"},
+        [("start", "App::Server"), ("stop", "App::Server"), ("default", "App::Server")],
+    )
+
+
+@case(tags=["symbol"])
+def case_ruby_constant() -> SymbolCase:
+    """Top-level constant."""
+    return "ruby", "MAX_SIZE = 100\n", [("variable", "MAX_SIZE", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_multiple_assignment() -> SymbolCase:
+    """Ruby multiple assignment of constants."""
+    return "ruby", "A, B = 1, 2\n", [("variable", "A", ""), ("variable", "B", "")]
+
+
+@case(tags=["symbol"])
+def case_ruby_splat_assignment() -> SymbolCase:
+    """Ruby splat target."""
+    return "ruby", "A, *B = list\n", [("variable", "A", ""), ("variable", "B", "")]
+
+
+@case(tags=["symbol"], marks=_xfail_nested)
+def case_ruby_nested_unpack_xfail() -> SymbolCase:
+    """Ruby nested destructuring — only the outer level captured today."""
+    return (
+        "ruby",
+        "(A, B), C = x\n",
+        [("variable", "A", ""), ("variable", "B", ""), ("variable", "C", "")],
+    )

rbtr_lang_ruby/tests/samples/ruby/config.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+# Greeter configuration.
+DEFAULT_LOCALE = "en"

rbtr_lang_ruby/tests/samples/ruby/ruby.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+# Greeter — format greetings for named recipients.
+#
+# The Ruby plugin extracts top-level defs (as functions), classes and
+# modules, defs inside them (as methods), constant assignments (as
+# variables, scoped to their class/module), the RSpec describe/it DSL
+# (groups as classes, examples as functions), and require /
+# require_relative imports.
+
+require "json"
+require_relative "./config"
+
+DEFAULT_GREETING = "Hello" # trailing comment: its own chunk
+
+# Standalone note, separated by blank lines from any definition.
+# Second line of the same block.
+
+# Mixin providing a shout helper.
+module Shoutable
+  def shout(message)
+    message.upcase
+  end
+end
+
+# Formats greetings with a prefix.
+class Greeter
+  include Shoutable
+
+  MAX_NAME_LENGTH = 64
+
+  def initialize(prefix = DEFAULT_GREETING)
+    @prefix = prefix
+  end
+
+  # Greet a single recipient.
+  def greet(name)
+    "#{@prefix}, #{name}"
+  end
+
+  def self.default
+    new(DEFAULT_GREETING)
+  end
+end
+
+# Top-level helper that builds a greeter and greets.
+def format_greeting(name)
+  Greeter.new.greet(name)
+end
+
+# RSpec-style specification exercising the describe/it DSL.
+RSpec.describe Greeter do
+  describe "#greet" do
+    it "includes the configured prefix" do
+      expect(Greeter.new.greet("Sam")).to include("Hello")
+    end
+  end
+end

rbtr_lang_ruby/tests/test_docstrings.py

@@ -0,0 +1,43 @@
+"""Ruby doc-comment extraction (Ruby is exterior-doc: leading comments attach via the sibling walk)."""
+
+from __future__ import annotations
+
+from pytest_cases import parametrize_with_cases
+
+from rbtr.git import FileEntry
+from rbtr.languages.extract import extract_file
+
+
+@parametrize_with_cases(
+    "lang, source, name, snippet", cases=".cases_docstrings", has_tag="documented"
+)
+def test_documented_chunk_includes_doc_text(
+    lang: str, source: str, name: str, snippet: str
+) -> None:
+    """By default the chunk content carries the symbol's docs."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    chunk = next(c for c in chunks if c.name == name)
+    assert snippet in chunk.content, f"expected {snippet!r} in {lang}.{name}: {chunk.content!r}"
+
+
+@parametrize_with_cases(
+    "lang, source, name, snippet", cases=".cases_docstrings", has_tag="undocumented"
+)
+def test_no_phantom_documentation(lang: str, source: str, name: str, snippet: str) -> None:
+    """Symbols without documentation do not gain any in content."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    chunk = next(c for c in chunks if c.name == name)
+    assert snippet not in chunk.content, (
+        f"unexpected {snippet!r} in {lang}.{name}: {chunk.content!r}"
+    )
+
+
+@parametrize_with_cases(
+    "lang, source, name, snippet", cases=".cases_docstrings", has_tag="exterior_doc"
+)
+def test_leading_doc_folds_into_symbol(lang: str, source: str, name: str, snippet: str) -> None:
+    """A leading comment block folds into its symbol's chunk content."""
+    chunk = next(
+        c for c in extract_file(FileEntry("input", "sha1", source.encode()), lang) if c.name == name
+    )
+    assert snippet in chunk.content

rbtr_lang_ruby/tests/test_extraction.py

@@ -0,0 +1,57 @@
+"""Ruby extraction tests (cases in `cases_extraction.py`)."""
+
+from __future__ import annotations
+
+from pytest_cases import parametrize_with_cases
+
+from rbtr.domain.models import ChunkKind, ImportMeta
+from rbtr.git import FileEntry
+from rbtr.languages.extract import extract_file
+
+
+@parametrize_with_cases("lang, source, expected", cases=".cases_extraction", has_tag="symbol")
+def test_extracts_expected_symbols(lang: str, source: str, expected: list) -> None:
+    """Each expected (kind, name, scope) tuple appears in the output."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    symbols = [(c.kind, c.name, c.scope) for c in chunks]
+    for exp in expected:
+        assert exp in symbols, f"expected {exp} not found in {symbols}"
+
+
+@parametrize_with_cases(
+    "lang, source, expected_kinds, expected_methods", cases=".cases_extraction", has_tag="mixed"
+)
+def test_extracts_all_expected_kinds(
+    lang: str, source: str, expected_kinds: set[str], expected_methods: list[tuple[str, str]]
+) -> None:
+    """Realistic source produces all expected chunk kinds and method scoping."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    kinds = {c.kind for c in chunks}
+    for kind in expected_kinds:
+        assert kind in kinds, f"expected kind {kind!r} not in {kinds}"
+    methods = [(c.name, c.scope) for c in chunks if c.kind == ChunkKind.METHOD]
+    for name, scope in expected_methods:
+        assert (name, scope) in methods, f"expected method ({name}, {scope}) not in {methods}"
+
+
+@parametrize_with_cases("lang, source, expected", cases=".cases_extraction", has_tag="import")
+def test_extracts_import_metadata(lang: str, source: str, expected: dict) -> None:
+    """First import chunk has the expected metadata."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    imports = [c for c in chunks if c.kind == ChunkKind.IMPORT]
+    assert len(imports) >= 1, f"no import chunks extracted from {source!r}"
+    assert imports[0].metadata == ImportMeta(**expected)
+
+
+@parametrize_with_cases(
+    "lang, source, count, metadata_list", cases=".cases_extraction", has_tag="multi_import"
+)
+def test_extracts_multi_import(
+    lang: str, source: str, count: int, metadata_list: list[dict]
+) -> None:
+    """Multiple imports have correct count and per-import metadata."""
+    chunks = extract_file(FileEntry("input", "sha1", source.encode()), lang)
+    imports = [c for c in chunks if c.kind == ChunkKind.IMPORT]
+    assert len(imports) == count
+    for imp, expected in zip(imports, metadata_list, strict=True):
+        assert imp.metadata == ImportMeta(**expected)

rbtr_lang_ruby/tests/test_samples.py

@@ -0,0 +1,75 @@
+"""Ruby sample extraction: the `samples/ruby/` project through the real pipeline."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+from tree_sitter import Parser
+
+from rbtr.domain.models import Chunk, ChunkKind, Edge
+from rbtr.git import FileEntry
+from rbtr.languages.edges import build_resolution_map, infer_import_edges
+from rbtr.languages.extract import extract_file
+from rbtr.languages.manager import get_manager
+from rbtr.testing import render_edges
+
+if TYPE_CHECKING:
+    from syrupy.assertion import SnapshotAssertion
+
+
+@pytest.fixture
+def project() -> list[tuple[str, str]]:
+    root = Path(__file__).parent / "samples" / "ruby"
+    return [
+        (str(p.relative_to(root)), p.read_text()) for p in sorted(root.rglob("*")) if p.is_file()
+    ]
+
+
+@pytest.fixture
+def chunks(project: list[tuple[str, str]]) -> list[Chunk]:
+    manager = get_manager()
+    out: list[Chunk] = []
+    for path, text in project:
+        lang = manager.detect_language(path) or "ruby"
+        out.extend(extract_file(FileEntry(path, "sha1", text.encode()), lang))
+    return out
+
+
+@pytest.fixture
+def edges(project: list[tuple[str, str]], chunks: list[Chunk]) -> list[Edge]:
+    manager = get_manager()
+    repo_files = {path for path, _ in project}
+    return infer_import_edges(chunks, repo_files, build_resolution_map(manager))
+
+
+def test_emits_expected_kinds(chunks: list[Chunk]) -> None:
+    """The sample exercises Ruby's function, class, method, variable, and import chunks."""
+    kinds = {c.kind for c in chunks}
+    assert {
+        ChunkKind.FUNCTION,
+        ChunkKind.CLASS,
+        ChunkKind.METHOD,
+        ChunkKind.VARIABLE,
+        ChunkKind.IMPORT,
+        ChunkKind.COMMENT,
+    } <= kinds
+
+
+def test_parses_cleanly(project: list[tuple[str, str]]) -> None:
+    manager = get_manager()
+    for path, text in project:
+        grammar = manager.grammar(manager.detect_language(path) or "ruby")
+        assert grammar is not None
+        assert not Parser(grammar).parse(text.encode()).root_node.has_error, path
+
+
+def test_extraction_matches_snapshot(chunks: list[Chunk], snapshot_json: SnapshotAssertion) -> None:
+    assert chunks == snapshot_json
+
+
+def test_edges_match_snapshot(
+    chunks: list[Chunk], edges: list[Edge], snapshot_json: SnapshotAssertion
+) -> None:
+    assert render_edges(edges, chunks) == snapshot_json

rbtr_lang_ruby-2026.9.0.dev0.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: rbtr-lang-ruby
+Version: 2026.9.0.dev0
+Summary: rbtr — Ruby language plugin
+Keywords: code-search,code-index,tree-sitter,static-analysis,semantic-search,developer-tools,ruby
+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 :: Ruby
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Text Processing :: Indexing
+Classifier: Typing :: Typed
+Requires-Dist: rbtr==2026.9.0.dev0
+Requires-Dist: tree-sitter-ruby
+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-ruby#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-ruby
+
+Ruby support for [rbtr]. Optional plugin — install with
+`pip install rbtr[ruby]`.
+
+[rbtr]: https://github.com/janrito/rbtr/tree/main/packages/rbtr#readme
+
+## What it ingests
+
+- **Functions & methods** — `def` (a method inside a class/module is scoped
+  to it; top-level `def` is a function).
+- **Classes** — `class` and `module` definitions (a module also scopes its
+  members).
+- **Variables** — constants and module-level assignments.
+- **Imports** — `require` and `require_relative`, for cross-file edges.
+
+Leading `#` doc comments fold into the symbol's content.
+
+## Chunks produced
+
+```ruby
+def greet(name); …; end          # function "greet"
+class User                       # class "User"
+  def save; …; end               #   method "save", scope "User"
+end
+MAX = 100                        # variable "MAX"
+require_relative "config"        # import, metadata {module: config}
+```
+
+## Embedded / injected chunks
+
+None. Ruby does not embed other languages.
+
+## Grammar & dependencies
+
+Uses the `tree-sitter-ruby` grammar. No dependency on other language plugins.

rbtr_lang_ruby-2026.9.0.dev0.dist-info/RECORD

@@ -0,0 +1,19 @@
+rbtr_lang_ruby/__init__.py,sha256=8Q8etdrHu12hNWd6hq_K70CwbyF-EeBDZKRvf7ViD4o,36
+rbtr_lang_ruby/plugin.py,sha256=o5rco7zB2RTYzZ8km-sMf7ZFj1p3lULc1Htlb3av3ek,3304
+rbtr_lang_ruby/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_ruby/ruby.scm,sha256=W3iazNFUbWa86o2iIslgsDR_SvPAU3MOddE_h42d7PU,1362
+rbtr_lang_ruby/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_ruby/tests/__snapshots__/test_samples/test_edges_match_snapshot.json,sha256=zTYX7J0wjD1YBx2mdYu8sNxr0W46-s2r4amwLzCyg-U,86
+rbtr_lang_ruby/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json,sha256=LfSrymZZbYF4QJDDZ8ej0Ts7vzPGuUaXnqp5hJ_0LlU,9563
+rbtr_lang_ruby/tests/cases_docstrings.py,sha256=eHnXQmbet2qBXsM7eujtkhd1MOg4mZQNyInrZ31PUNU,2958
+rbtr_lang_ruby/tests/cases_extraction.py,sha256=N8Inv2njzoRb68b1TkfUnOSBn5XcS_WCTksQF-zU32U,7288
+rbtr_lang_ruby/tests/samples/ruby/config.rb,sha256=dp2cfJf-qJYWg4gx1wewcQklVHY28Gjc_hVo43OujTo,78
+rbtr_lang_ruby/tests/samples/ruby/ruby.rb,sha256=MdEK71xnjroo8XXSt3Q8wXIH0tlJhQsYWp6ao0H6gTs,1331
+rbtr_lang_ruby/tests/test_docstrings.py,sha256=pTYLeKr4Gmb3_E4kiwnnCJBV_plOxXy7dQhO-3DYHyU,1752
+rbtr_lang_ruby/tests/test_extraction.py,sha256=-eQZOo4BWtfOV3MUHWVocQkP1Vkgcs36D_YpfPuTDMw,2655
+rbtr_lang_ruby/tests/test_samples.py,sha256=QJ0qb-Q0GwCEgRUcvGlV49DxtTR0cvpVpK5B6mKOxII,2393
+rbtr_lang_ruby-2026.9.0.dev0.dist-info/licenses/LICENSE,sha256=3LvNTMhogXUXkHsDvTWaXdtGd9C-uuoIVD1ey8w9ITs,1077
+rbtr_lang_ruby-2026.9.0.dev0.dist-info/WHEEL,sha256=-i9oRNYVXXZJUIYl5zclLIg6onEb0NLibTX34uln84w,81
+rbtr_lang_ruby-2026.9.0.dev0.dist-info/entry_points.txt,sha256=bOb0oogqZZYs1lO5T3A-ftmYBoF65WXloUNxx4rX_Tg,52
+rbtr_lang_ruby-2026.9.0.dev0.dist-info/METADATA,sha256=LXK24nhttttqhUt2fxbTAhNI8XY39ajwu9pbYCEO9iY,2284
+rbtr_lang_ruby-2026.9.0.dev0.dist-info/RECORD,,

rbtr_lang_ruby-2026.9.0.dev0.dist-info/WHEEL

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

rbtr_lang_ruby-2026.9.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[rbtr.languages]
+ruby = rbtr_lang_ruby.plugin:ruby
+

rbtr_lang_ruby-2026.9.0.dev0.dist-info/licenses/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.