rbtr-lang-go 2026.7.0.dev0__py3-none-any.whl

rbtr_lang_go/__init__.py

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

rbtr_lang_go/go.scm

@@ -0,0 +1,53 @@
+; Top-level comments (Go uses one `comment` type for `//` and `/* */`).
+; The engine groups these and folds a block flush before a symbol into it.
+(comment) @comment
+
+(function_declaration
+  name: (identifier) @_fn_name) @function
+
+(method_declaration
+  receiver: (parameter_list
+    (parameter_declaration
+      type: [
+        (type_identifier) @_scope
+        (pointer_type (type_identifier) @_scope)
+      ]))
+  name: (field_identifier) @_method_name) @method
+
+(type_declaration
+  (type_spec
+    name: (type_identifier) @_cls_name)) @class
+
+(type_spec
+  (interface_type
+    (method_elem
+      name: (field_identifier) @_method_name) @method))
+
+(type_declaration
+  (type_alias
+    name: (type_identifier) @_cls_name)) @class
+
+(import_declaration
+  (import_spec
+    path: (interpreted_string_literal) @_import_module) @import)
+
+(import_declaration
+  (import_spec_list
+    (import_spec
+      path: (interpreted_string_literal) @_import_module) @import))
+
+(source_file
+  (var_declaration
+    (var_spec
+      name: (identifier) @_var_name) @variable))
+
+(source_file
+  (const_declaration
+    (const_spec
+      name: (identifier) @_var_name) @variable))
+
+(source_file
+  (var_declaration
+    (var_spec_list
+      (var_spec
+        name: (identifier) @_var_name) @variable)))

rbtr_lang_go/plugin.py

@@ -0,0 +1,38 @@
+"""Go language plugin.
+
+Provides full support: functions, methods, type declarations,
+and import extraction.
+
+Extracted chunks::
+
+    func hello() {}                 → function "hello", scope ""
+    func (u User) Name() string {}  → method "Name", scope ""
+    type User struct { ... }        → class "User", scope ""
+    type Reader interface { ... }   → class "Reader", scope ""
+
+    import "fmt"
+        → import, metadata {module: "fmt"}
+    import ("fmt" "os/exec")
+        → 2 import chunks: {module: "fmt"}, {module: "os/exec"}
+"""
+
+from __future__ import annotations
+
+from rbtr.languages.registration import LanguageRegistration, QueryExtraction, load_query
+
+# ── Query ────────────────────────────────────────────────────────────
+
+
+# ── Plugin ───────────────────────────────────────────────────────────
+
+
+go = LanguageRegistration(
+    id="go",
+    extensions=frozenset({".go"}),
+    grammar_module="tree_sitter_go",
+    extraction=QueryExtraction(
+        query=load_query(__package__, "go"),
+        scope_types=frozenset({"type_spec"}),
+    ),
+    extraction_serial=4,
+)

rbtr_lang_go/tests/__snapshots__/test_samples/test_edges_match_snapshot.json

@@ -0,0 +1,3 @@
+[
+  "go.go::\"greeter/util\" -> greeter/util.go::Trim [imports]"
+]

rbtr_lang_go/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json

@@ -0,0 +1,308 @@
+[
+  {
+    "id": "d1f4278c0ca4e638",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "go",
+    "content": "// Package greet formats greetings for named recipients.\n//\n// The Go plugin extracts functions, methods (functions with a\n// receiver), type declarations (struct, interface, and alias, as\n// classes), const/var declarations (as variables), and imports.",
+    "line_start": 1,
+    "line_end": 5,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "617a74fefdf94501",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "import",
+    "name": "\"fmt\"",
+    "scope": "",
+    "language": "go",
+    "content": "\"fmt\"",
+    "line_start": 9,
+    "line_end": 9,
+    "metadata": {
+      "module": "fmt",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "22c93a3cd18d6a4e",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "import",
+    "name": "\"greeter/util\"",
+    "scope": "",
+    "language": "go",
+    "content": "\"greeter/util\"",
+    "line_start": 11,
+    "line_end": 11,
+    "metadata": {
+      "module": "greeter/util",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "1bc7a9beaa5abc1f",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "go",
+    "content": "// DefaultGreeting is the fallback prefix.",
+    "line_start": 14,
+    "line_end": 14,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "6088984e54e72e54",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "variable",
+    "name": "DefaultGreeting",
+    "scope": "",
+    "language": "go",
+    "content": "DefaultGreeting = \"Hello\"",
+    "line_start": 15,
+    "line_end": 15,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "8682e0e6778060e5",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "variable",
+    "name": "fallbackLocale",
+    "scope": "",
+    "language": "go",
+    "content": "fallbackLocale = \"en\"",
+    "line_start": 17,
+    "line_end": 17,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "6cf50d84e9893957",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "go",
+    "content": "// trailing comment: its own chunk, not folded",
+    "line_start": 17,
+    "line_end": 17,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "6d998cbd76a60714",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "class",
+    "name": "Temperature",
+    "scope": "",
+    "language": "go",
+    "content": "// Temperature is an alias for the underlying float type.\ntype Temperature = float64",
+    "line_start": 19,
+    "line_end": 20,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "3f6b670c5127f21d",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "class",
+    "name": "Greeter",
+    "scope": "",
+    "language": "go",
+    "content": "// Greeter holds a greeting prefix.\ntype Greeter struct {\n\tPrefix string\n}",
+    "line_start": 22,
+    "line_end": 25,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "373545cefb441d30",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "class",
+    "name": "Formatter",
+    "scope": "",
+    "language": "go",
+    "content": "// Formatter renders a greeting for a name.\ntype Formatter interface {\n\tFormat(name string) string\n}",
+    "line_start": 27,
+    "line_end": 30,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "7c2d2b8469f4c6b9",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "method",
+    "name": "Format",
+    "scope": "Formatter",
+    "language": "go",
+    "content": "Format(name string) string",
+    "line_start": 29,
+    "line_end": 29,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "77923e25be8f065d",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "go",
+    "content": "// Standalone note, separated by blank lines from any definition.\n// Second line of the same block.",
+    "line_start": 32,
+    "line_end": 33,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "d49eb7eef5c71c0f",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "method",
+    "name": "Greet",
+    "scope": "Greeter",
+    "language": "go",
+    "content": "// Greet greets a single recipient.\nfunc (g Greeter) Greet(name string) string {\n\treturn fmt.Sprintf(\"%s, %s\", g.Prefix, util.Trim(name))\n}",
+    "line_start": 35,
+    "line_end": 38,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "8355f60b7f62d374",
+    "blob_sha": "sha1",
+    "file_path": "go.go",
+    "kind": "function",
+    "name": "FormatGreeting",
+    "scope": "",
+    "language": "go",
+    "content": "// FormatGreeting formats a greeting via a Greeter.\nfunc FormatGreeting(g Greeter, name string) string {\n\treturn g.Greet(name)\n}",
+    "line_start": 40,
+    "line_end": 43,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "19cd38988ba480c4",
+    "blob_sha": "sha1",
+    "file_path": "greeter/util.go",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "go",
+    "content": "// Package util holds greeting helpers.",
+    "line_start": 1,
+    "line_end": 1,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "d2279d95b96822bc",
+    "blob_sha": "sha1",
+    "file_path": "greeter/util.go",
+    "kind": "import",
+    "name": "\"strings\"",
+    "scope": "",
+    "language": "go",
+    "content": "\"strings\"",
+    "line_start": 4,
+    "line_end": 4,
+    "metadata": {
+      "module": "strings",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "5d95fbaf4ba5f22b",
+    "blob_sha": "sha1",
+    "file_path": "greeter/util.go",
+    "kind": "function",
+    "name": "Trim",
+    "scope": "",
+    "language": "go",
+    "content": "// Trim removes surrounding whitespace from a name.\nfunc Trim(name string) string {\n\treturn strings.TrimSpace(name)\n}",
+    "line_start": 6,
+    "line_end": 9,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  }
+]

rbtr_lang_go/tests/cases_docstrings.py

@@ -0,0 +1,140 @@
+"""Go 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_go_doc_comment_on_function() -> DocstringCase:
+    """Canonical Go doc comment above `func`."""
+    src = """\
+package main
+
+// Greet says hello.
+func Greet() {}
+"""
+    return "go", src, "Greet", "Greet says hello"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_go_doc_comment_on_type() -> DocstringCase:
+    """Doc comment above a `type` declaration."""
+    src = """\
+package main
+
+// Widget is a UI element.
+type Widget struct {
+    name string
+}
+"""
+    return "go", src, "Widget", "Widget is a UI element"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_go_doc_comment_on_method() -> DocstringCase:
+    """Doc comment above a method receiver."""
+    src = """\
+package main
+
+type T struct{}
+
+// Do performs the action.
+func (t *T) Do() {}
+"""
+    return "go", src, "Do", "Do performs the action"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_go_multi_line_doc_comment() -> DocstringCase:
+    """Multi-line `//` doc-comment run."""
+    src = """\
+package main
+
+// Compute executes the pipeline.
+//
+// It returns an error if the inputs do not validate.
+func Compute() error { return nil }
+"""
+    return "go", src, "Compute", "It returns an error if the inputs"
+
+
+@case(tags=["documented", "edge_case", "exterior_doc"])
+def case_go_block_comment() -> DocstringCase:
+    """`/* ... */` block comment as Go-doc.  Supported by
+    `go doc` but rare.
+    """
+    src = """\
+package main
+
+/* Block doc above foo.
+   Continues here. */
+func Foo() {}
+"""
+    return "go", src, "Foo", "Block doc above foo"
+
+
+@case(tags=["documented", "unconventional", "exterior_doc"])
+def case_go_non_godoc_style_comment() -> DocstringCase:
+    """Comment that does *not* begin with the symbol's name.
+    `go doc` would warn, but rbtr leans toward flexibility and
+    attaches it.
+    """
+    src = """\
+package main
+
+// Deliberately unconventional opening.
+func Work() {}
+"""
+    return "go", src, "Work", "Deliberately unconventional opening"
+
+
+@case(tags=["undocumented", "no_docs"])
+def case_go_fn_without_doc() -> DocstringCase:
+    """Undocumented function."""
+    src = """\
+package main
+
+func bare() {}
+"""
+    return "go", src, "bare", "PHANTOM_DOC_TEXT_SHOULD_NEVER_APPEAR"
+
+
+@case(tags=["undocumented", "boundary_not_attached"])
+def case_go_doc_detached_by_blank_line() -> DocstringCase:
+    """Blank line breaks attachment — the Go style guide
+    explicitly forbids a blank line between a doc comment and
+    its symbol.
+    """
+    src = """\
+package main
+
+// Orphan.
+
+func Later() {}
+"""
+    return "go", src, "Later", "Orphan"
+
+
+@case(tags=["undocumented", "invalid"])
+def case_go_doc_comment_above_previous_function_not_attached() -> DocstringCase:
+    """Comment between two `func`s belongs to the second one,
+    not the first.  The walk starts from the symbol and goes
+    *backwards*, so the comment correctly attaches to `Second`.
+    We probe the chunk for the *first* function to confirm it
+    does not steal the comment.
+    """
+    src = """\
+package main
+
+func First() {}
+
+// Doc for Second.
+func Second() {}
+"""
+    return "go", src, "First", "Doc for Second"

rbtr_lang_go/tests/cases_extraction.py

@@ -0,0 +1,294 @@
+"""Go 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_go_function() -> SymbolCase:
+    """func hello() {}."""
+    src = """\
+package main
+
+func hello() {}
+"""
+    return "go", src, [("function", "hello", "")]
+
+
+@case(tags=["symbol"])
+def case_go_function_params() -> SymbolCase:
+    """func add(a int, b int) int."""
+    src = """\
+package main
+
+func add(a int, b int) int { return a + b }
+"""
+    return "go", src, [("function", "add", "")]
+
+
+@case(tags=["symbol"])
+def case_go_multiple_functions() -> SymbolCase:
+    """Multiple functions."""
+    src = """\
+package main
+
+func foo() {}
+func bar() {}
+func baz() {}
+"""
+    return (
+        "go",
+        src,
+        [
+            ("function", "foo", ""),
+            ("function", "bar", ""),
+            ("function", "baz", ""),
+        ],
+    )
+
+
+@case(tags=["symbol"])
+def case_go_method() -> SymbolCase:
+    """Value receiver method."""
+    src = """\
+package main
+
+type User struct{}
+
+func (u User) Name() string { return u.name }
+"""
+    return "go", src, [("method", "Name", "User")]
+
+
+@case(tags=["symbol"])
+def case_go_pointer_method() -> SymbolCase:
+    """Pointer receiver method."""
+    src = """\
+package main
+
+type Svc struct{}
+
+func (s *Svc) Start() {}
+"""
+    return "go", src, [("method", "Start", "Svc")]
+
+
+@case(tags=["symbol"])
+def case_go_struct() -> SymbolCase:
+    """type User struct."""
+    src = """\
+package main
+
+type User struct {
+    Name string
+}
+"""
+    return "go", src, [("class", "User", "")]
+
+
+@case(tags=["symbol"])
+def case_go_interface() -> SymbolCase:
+    """type Reader interface."""
+    src = """\
+package main
+
+type Reader interface {
+    Read(p []byte) (int, error)
+}
+"""
+    return "go", src, [("class", "Reader", "")]
+
+
+@case(tags=["symbol"])
+def case_go_type_alias() -> SymbolCase:
+    """type ID string."""
+    src = """\
+package main
+
+type ID string
+"""
+    return "go", src, [("class", "ID", "")]
+
+
+@case(tags=["symbol"])
+def case_go_multiple_types() -> SymbolCase:
+    """Multiple type declarations."""
+    src = """\
+package main
+
+type Foo struct{}
+type Bar struct{}
+"""
+    return "go", src, [("class", "Foo", ""), ("class", "Bar", "")]
+
+
+@case(tags=["import"])
+def case_go_import_single() -> ImportCase:
+    """import "fmt"."""
+    src = """\
+package main
+import "fmt"
+"""
+    return "go", src, {"module": "fmt"}
+
+
+@case(tags=["import"])
+def case_go_import_nested() -> ImportCase:
+    """import "os/exec"."""
+    src = """\
+package main
+import "os/exec"
+"""
+    return "go", src, {"module": "os/exec"}
+
+
+@case(tags=["import"])
+def case_go_import_url() -> ImportCase:
+    """import "github.com/user/repo"."""
+    src = """\
+package main
+import "github.com/user/repo"
+"""
+    return "go", src, {"module": "github.com/user/repo"}
+
+
+@case(tags=["import"])
+def case_go_import_aliased() -> ImportCase:
+    """import f "fmt" — alias ignored, module captured."""
+    src = """\
+package main
+import f "fmt"
+"""
+    return "go", src, {"module": "fmt"}
+
+
+@case(tags=["multi_import"])
+def case_go_import_grouped() -> MultiImportCase:
+    """import ("fmt" "os") — separate chunks per spec."""
+    src = """\
+package main
+import (
+    "fmt"
+    "os"
+)
+"""
+    return (
+        "go",
+        src,
+        2,
+        [{"module": "fmt"}, {"module": "os"}],
+    )
+
+
+@case(tags=["multi_import"])
+def case_go_import_grouped_paths() -> MultiImportCase:
+    """Grouped import with nested paths — separate chunks."""
+    src = """\
+package main
+import (
+    "fmt"
+    "os/exec"
+    "net/http"
+)
+"""
+    return (
+        "go",
+        src,
+        3,
+        [{"module": "fmt"}, {"module": "os/exec"}, {"module": "net/http"}],
+    )
+
+
+@case(tags=["import"])
+def case_go_import_grouped_single() -> ImportCase:
+    """Grouped import with one item."""
+    src = """\
+package main
+import (
+    "fmt"
+)
+"""
+    return "go", src, {"module": "fmt"}
+
+
+@case(tags=["mixed"])
+def case_go_full_module() -> MixedCase:
+    """Realistic Go module with godoc-style comments.
+
+    Expected-kinds tuple unchanged; content assertions are in
+    `test_docstrings.py`.
+    """
+    src = """\
+package main
+
+import (
+    "fmt"
+    "os"
+)
+
+// Config is the runtime configuration for the service.
+type Config struct {
+    Name string
+}
+
+// String returns a human-readable summary of the Config.
+func (c Config) String() string { return c.Name }
+
+// main is the entry point for the service.
+func main() {
+    fmt.Println("hello")
+}
+"""
+    return "go", src, {"import", "class", "method", "function"}, [("String", "Config")]
+
+
+@case(tags=["symbol"])
+def case_go_package_var() -> SymbolCase:
+    """Package-level var."""
+    return "go", "package main\nvar MaxSize = 100\n", [("variable", "MaxSize", "")]
+
+
+@case(tags=["symbol"])
+def case_go_package_const() -> SymbolCase:
+    """Package-level const."""
+    return "go", "package main\nconst Timeout = 30\n", [("variable", "Timeout", "")]
+
+
+@case(tags=["symbol"])
+def case_go_grouped_var() -> SymbolCase:
+    """Go grouped var block."""
+    src = """\
+package m
+
+var (
+	X = 1
+	Y = 2
+)
+"""
+    return "go", src, [("variable", "X", ""), ("variable", "Y", "")]
+
+
+@case(tags=["symbol"])
+def case_go_grouped_const() -> SymbolCase:
+    """Go grouped const block (already supported — regression guard)."""
+    src = """\
+package m
+
+const (
+	A = 1
+	B = 2
+)
+"""
+    return "go", src, [("variable", "A", ""), ("variable", "B", "")]

rbtr_lang_go/tests/samples/go/go.go

@@ -0,0 +1,43 @@
+// Package greet formats greetings for named recipients.
+//
+// The Go plugin extracts functions, methods (functions with a
+// receiver), type declarations (struct, interface, and alias, as
+// classes), const/var declarations (as variables), and imports.
+package greet
+
+import (
+	"fmt"
+
+	"greeter/util"
+)
+
+// DefaultGreeting is the fallback prefix.
+const DefaultGreeting = "Hello"
+
+var fallbackLocale = "en" // trailing comment: its own chunk, not folded
+
+// Temperature is an alias for the underlying float type.
+type Temperature = float64
+
+// Greeter holds a greeting prefix.
+type Greeter struct {
+	Prefix string
+}
+
+// Formatter renders a greeting for a name.
+type Formatter interface {
+	Format(name string) string
+}
+
+// Standalone note, separated by blank lines from any definition.
+// Second line of the same block.
+
+// Greet greets a single recipient.
+func (g Greeter) Greet(name string) string {
+	return fmt.Sprintf("%s, %s", g.Prefix, util.Trim(name))
+}
+
+// FormatGreeting formats a greeting via a Greeter.
+func FormatGreeting(g Greeter, name string) string {
+	return g.Greet(name)
+}

rbtr_lang_go/tests/samples/go/greeter/util.go

@@ -0,0 +1,9 @@
+// Package util holds greeting helpers.
+package util
+
+import "strings"
+
+// Trim removes surrounding whitespace from a name.
+func Trim(name string) string {
+	return strings.TrimSpace(name)
+}

rbtr_lang_go/tests/test_docstrings.py

@@ -0,0 +1,45 @@
+"""Go doc-comment extraction (Go 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 doc comment folds into its symbol: it appears in the chunk
+    content and the chunk starts on the comment's line, above the definition."""
+    chunk = next(
+        c for c in extract_file(FileEntry("input", "sha1", source.encode()), lang) if c.name == name
+    )
+    assert snippet in chunk.content
+    assert chunk.content.lstrip().startswith(("//", "/*"))

rbtr_lang_go/tests/test_extraction.py

@@ -0,0 +1,57 @@
+"""Go extraction tests (cases in `cases_extraction.py`)."""
+
+from __future__ import annotations
+
+from pytest_cases import parametrize_with_cases
+
+from rbtr.git import FileEntry
+from rbtr.index.models import ChunkKind, ImportMeta
+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_go/tests/test_samples.py

@@ -0,0 +1,74 @@
+"""go sample extraction: the `samples/go/` 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.git import FileEntry
+from rbtr.index.models import Chunk, ChunkKind, Edge
+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" / "go"
+    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 "go"
+        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:
+    kinds = {c.kind for c in chunks}
+    assert {
+        ChunkKind.FUNCTION,
+        ChunkKind.METHOD,
+        ChunkKind.CLASS,
+        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 "go")
+        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_go-2026.7.0.dev0.dist-info/METADATA

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: rbtr-lang-go
+Version: 2026.7.0.dev0
+Summary: rbtr — Go language plugin
+License-Expression: MIT
+Requires-Dist: rbtr==2026.7.0.dev0
+Requires-Dist: tree-sitter-go
+Requires-Python: >=3.13

rbtr_lang_go-2026.7.0.dev0.dist-info/RECORD

@@ -0,0 +1,18 @@
+rbtr_lang_go/__init__.py,sha256=ESnwM06MFOjJEdiK8MbCsQGStwLJ-2n0AIgzYpsuZkg,34
+rbtr_lang_go/go.scm,sha256=t2T5WwXqMNkGa0TT9PIT9ue_2nTO-TubZdKobz90v5w,1271
+rbtr_lang_go/plugin.py,sha256=zKsesdh0CLCRdr68dKbbb_5xjtzu5zQjzBvTS-yQpIw,1342
+rbtr_lang_go/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_go/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_go/tests/__snapshots__/test_samples/test_edges_match_snapshot.json,sha256=nBRO23R3ddiNmQUm5ndA5lSDAdOJH0iAQWPErqpe4As,67
+rbtr_lang_go/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json,sha256=6Iy2ie47Ety7dICpKLXhh5bOA3DBXuSTU0rMCngRZyg,7182
+rbtr_lang_go/tests/cases_docstrings.py,sha256=9cV3w9AxmMm9ZDaO3u1Bv-AHeXHAgnHL7IHe-U9fq9A,3453
+rbtr_lang_go/tests/cases_extraction.py,sha256=hprGkPynyITK8U2VY_bdk6E6nA6HBEcF8UWK_9J_o7o,5810
+rbtr_lang_go/tests/samples/go/go.go,sha256=_PhwkrAMIaFZfXO-4WkEr0b7thT_GQ1s1HAP2T70vtE,1090
+rbtr_lang_go/tests/samples/go/greeter/util.go,sha256=6JsGe7imJr6rcCj4jfTJf9uDpbTGD7l0sYtI4BGvYlU,190
+rbtr_lang_go/tests/test_docstrings.py,sha256=HLh5Rv-LRO_Fjt04yJ1jijwjDpnSJxJ2KqrJHWWr8VY,1891
+rbtr_lang_go/tests/test_extraction.py,sha256=5CmjbgGegt-UWCvtTO_6cIJx39BuWawhJHj-SAmTn9s,2652
+rbtr_lang_go/tests/test_samples.py,sha256=JdFj3Zyq6NnbPukt76KOI7fiWr-WmMQbCIy9BqGO94o,2290
+rbtr_lang_go-2026.7.0.dev0.dist-info/WHEEL,sha256=CoDSoyhtC_eO_tlxRYzsTraPv1fPJRXFx91k6ISeAvA,81
+rbtr_lang_go-2026.7.0.dev0.dist-info/entry_points.txt,sha256=7KT_1_hCbZVpXXkfDXPjHoop0XPZK3GUCGqczFOrWGw,46
+rbtr_lang_go-2026.7.0.dev0.dist-info/METADATA,sha256=c_RgDm3iQeqSO9C6BOo6ABB7N-BkZ4ul3oFElZkegL4,214
+rbtr_lang_go-2026.7.0.dev0.dist-info/RECORD,,

rbtr_lang_go-2026.7.0.dev0.dist-info/WHEEL

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

rbtr_lang_go-2026.7.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[rbtr.languages]
+go = rbtr_lang_go.plugin:go
+