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

rbtr_lang_java/__init__.py

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

rbtr_lang_java/java.scm

@@ -0,0 +1,45 @@
+; Top-level comments (Java: `//` line and `/* */`, `/** */` block).
+[(line_comment) (block_comment)] @comment
+
+(method_declaration
+  name: (identifier) @_method_name) @method
+
+(constructor_declaration
+  name: (identifier) @_method_name) @method
+
+(field_declaration
+  declarator: (variable_declarator
+    name: (identifier) @_var_name)) @variable
+
+(class_declaration
+  name: (identifier) @_cls_name) @class
+
+(interface_declaration
+  name: (identifier) @_cls_name) @class
+
+(enum_declaration
+  name: (identifier) @_cls_name) @class
+
+(enum_declaration
+  body: (enum_body
+    (enum_constant
+      name: (identifier) @_var_name) @variable))
+
+(record_declaration
+  name: (identifier) @_cls_name) @class
+
+(record_declaration
+  parameters: (formal_parameters
+    (formal_parameter
+      name: (identifier) @_var_name) @variable))
+
+(annotation_type_declaration
+  name: (identifier) @_cls_name) @class
+
+(annotation_type_declaration
+  body: (annotation_type_body
+    (annotation_type_element_declaration
+      name: (identifier) @_method_name) @method))
+
+(import_declaration
+  (scoped_identifier) @_import_module) @import

rbtr_lang_java/plugin.py

@@ -0,0 +1,52 @@
+"""Java language plugin.
+
+Provides class, method, and import extraction.
+
+Extracted chunks::
+
+    class User {}                   → class "User", scope ""
+    class Service {
+        void process() {}           → method "process", scope "Service"
+    }
+
+    import java.util.HashMap
+        → import, metadata {module: "java.util.HashMap"}
+    import static org.junit.Assert.assertEquals
+        → import, metadata {module: "org.junit.Assert.assertEquals"}
+"""
+
+from __future__ import annotations
+
+from rbtr.languages.registration import (
+    LanguageRegistration,
+    ModuleStyle,
+    QueryExtraction,
+    load_query,
+)
+
+# ── Query ────────────────────────────────────────────────────────────
+
+
+# ── Plugin ───────────────────────────────────────────────────────────
+
+
+java = LanguageRegistration(
+    id="java",
+    extensions=frozenset({".java"}),
+    grammar_module="tree_sitter_java",
+    extraction=QueryExtraction(
+        query=load_query(__package__, "java"),
+        scope_types=frozenset(
+            {
+                "class_declaration",
+                "interface_declaration",
+                "enum_declaration",
+                "record_declaration",
+                "annotation_type_declaration",
+            }
+        ),
+    ),
+    source_roots=("", "src/main/java"),
+    module_style=ModuleStyle.DOTTED,
+    extraction_serial=4,
+)

rbtr_lang_java/tests/__snapshots__/test_samples/test_edges_match_snapshot.json

@@ -0,0 +1,4 @@
+[
+  "java.java::import com.example.format.Formatter; -> com/example/format/Formatter.java::Formatter [imports]",
+  "java.java::import com.example.format.Formatter; -> com/example/format/Formatter.java::format [imports]"
+]

rbtr_lang_java/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json

@@ -0,0 +1,488 @@
+[
+  {
+    "id": "fc9fe882b78bd247",
+    "blob_sha": "sha1",
+    "file_path": "com/example/format/Formatter.java",
+    "kind": "class",
+    "name": "Formatter",
+    "scope": "",
+    "language": "java",
+    "content": "/** Formats a greeting for a recipient. */\npublic interface Formatter {\n    String format(String name);\n}",
+    "line_start": 3,
+    "line_end": 6,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "831f35e91399ffb5",
+    "blob_sha": "sha1",
+    "file_path": "com/example/format/Formatter.java",
+    "kind": "method",
+    "name": "format",
+    "scope": "Formatter",
+    "language": "java",
+    "content": "String format(String name);",
+    "line_start": 5,
+    "line_end": 5,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "71ecb390e7b4b164",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "java",
+    "content": "// Greeter — format greetings for named recipients.\n//\n// The Java plugin extracts classes, methods (including constructors),\n// fields (as variables), and imports. Interfaces, enums, and records are\n// captured as classes, and their members scope to them.",
+    "line_start": 1,
+    "line_end": 5,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "496c3cb5ac915731",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "import",
+    "name": "import java.util.List;",
+    "scope": "",
+    "language": "java",
+    "content": "import java.util.List;",
+    "line_start": 8,
+    "line_end": 8,
+    "metadata": {
+      "module": "java.util.List",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "1417b33862ecea43",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "import",
+    "name": "import static java.util.Collections.emptyList;",
+    "scope": "",
+    "language": "java",
+    "content": "import static java.util.Collections.emptyList;",
+    "line_start": 9,
+    "line_end": 9,
+    "metadata": {
+      "module": "java.util.Collections.emptyList",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "d73548d67a52b30e",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "import",
+    "name": "import com.example.format.Formatter;",
+    "scope": "",
+    "language": "java",
+    "content": "import com.example.format.Formatter;",
+    "line_start": 11,
+    "line_end": 11,
+    "metadata": {
+      "module": "com.example.format.Formatter",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "680cae9e7fb01702",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "comment",
+    "name": "<anonymous>",
+    "scope": "",
+    "language": "java",
+    "content": "// Standalone note at top level, separated by blank lines.\n// Second line of the same block.",
+    "line_start": 13,
+    "line_end": 14,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "9f228cd99b8a722d",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "class",
+    "name": "Greeter",
+    "scope": "",
+    "language": "java",
+    "content": "/** Formats greetings with a configurable prefix. */\npublic class Greeter implements Formatter {\n    private final String prefix;\n\n    public Greeter(String prefix) {\n        this.prefix = prefix;\n    }\n\n    /** Format a greeting (implements the Formatter contract). */\n    @Override\n    public String format(String name) {\n        return greet(name);\n    }\n\n    /** Greet a single recipient. */\n    public String greet(String name) {\n        return prefix + \", \" + name;\n    }\n\n    /** Build a greeter with the default prefix. */\n    public static Greeter withDefault() {\n        return new Greeter(\"Hello\");\n    }\n\n    /** A nested formatter. */\n    static class Formatter {\n        String format(String name) {\n            return name.trim();\n        }\n    }\n}",
+    "line_start": 16,
+    "line_end": 46,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "bb5b1c7efa17f676",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "variable",
+    "name": "prefix",
+    "scope": "Greeter",
+    "language": "java",
+    "content": "private final String prefix;",
+    "line_start": 18,
+    "line_end": 18,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "b175d0c46cc7da3a",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "Greeter",
+    "scope": "Greeter",
+    "language": "java",
+    "content": "public Greeter(String prefix) {\n        this.prefix = prefix;\n    }",
+    "line_start": 20,
+    "line_end": 22,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "4bc1972beed0cee5",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "format",
+    "scope": "Greeter",
+    "language": "java",
+    "content": "/** Format a greeting (implements the Formatter contract). */\n    @Override\n    public String format(String name) {\n        return greet(name);\n    }",
+    "line_start": 24,
+    "line_end": 28,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "d158fb2366c6f729",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "greet",
+    "scope": "Greeter",
+    "language": "java",
+    "content": "/** Greet a single recipient. */\n    public String greet(String name) {\n        return prefix + \", \" + name;\n    }",
+    "line_start": 30,
+    "line_end": 33,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "a430bbda70683d09",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "withDefault",
+    "scope": "Greeter",
+    "language": "java",
+    "content": "/** Build a greeter with the default prefix. */\n    public static Greeter withDefault() {\n        return new Greeter(\"Hello\");\n    }",
+    "line_start": 35,
+    "line_end": 38,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "aa7f19020a4a06cf",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "class",
+    "name": "Formatter",
+    "scope": "Greeter",
+    "language": "java",
+    "content": "/** A nested formatter. */\n    static class Formatter {\n        String format(String name) {\n            return name.trim();\n        }\n    }",
+    "line_start": 40,
+    "line_end": 45,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "1345e44e8cd717a6",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "format",
+    "scope": "Greeter::Formatter",
+    "language": "java",
+    "content": "String format(String name) {\n            return name.trim();\n        }",
+    "line_start": 42,
+    "line_end": 44,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "877bfd5e977208c1",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "class",
+    "name": "Strategy",
+    "scope": "",
+    "language": "java",
+    "content": "/** A greeting strategy contract. */\ninterface Strategy {\n    String render(String name);\n}",
+    "line_start": 48,
+    "line_end": 51,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "0b7ec1f5873ad261",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "render",
+    "scope": "Strategy",
+    "language": "java",
+    "content": "String render(String name);",
+    "line_start": 50,
+    "line_end": 50,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "9fc1d873760c9177",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "class",
+    "name": "Tone",
+    "scope": "",
+    "language": "java",
+    "content": "/** Supported greeting tones. */\nenum Tone {\n    FORMAL,\n    CASUAL;\n\n    /** Human-readable label for this tone. */\n    String label() {\n        return name().toLowerCase();\n    }\n}",
+    "line_start": 53,
+    "line_end": 62,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "be3519be22988025",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "variable",
+    "name": "FORMAL",
+    "scope": "Tone",
+    "language": "java",
+    "content": "FORMAL",
+    "line_start": 55,
+    "line_end": 55,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "1a5686337ef56a40",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "variable",
+    "name": "CASUAL",
+    "scope": "Tone",
+    "language": "java",
+    "content": "CASUAL",
+    "line_start": 56,
+    "line_end": 56,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "9d6647628805f6cd",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "label",
+    "scope": "Tone",
+    "language": "java",
+    "content": "/** Human-readable label for this tone. */\n    String label() {\n        return name().toLowerCase();\n    }",
+    "line_start": 58,
+    "line_end": 61,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "7f673931d7852ccf",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "class",
+    "name": "Recipient",
+    "scope": "",
+    "language": "java",
+    "content": "/** An immutable named recipient. */\nrecord Recipient(String name, String locale) {\n    /** Full display name including locale. */\n    String display() {\n        return name + \" (\" + locale + \")\";\n    }\n}",
+    "line_start": 64,
+    "line_end": 70,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "47fb3098b5c5bbe0",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "variable",
+    "name": "name",
+    "scope": "Recipient",
+    "language": "java",
+    "content": "String name",
+    "line_start": 65,
+    "line_end": 65,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "e1c6599ad1ee4d57",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "variable",
+    "name": "locale",
+    "scope": "Recipient",
+    "language": "java",
+    "content": "String locale",
+    "line_start": 65,
+    "line_end": 65,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "e2ebf0a0194fd190",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "display",
+    "scope": "Recipient",
+    "language": "java",
+    "content": "/** Full display name including locale. */\n    String display() {\n        return name + \" (\" + locale + \")\";\n    }",
+    "line_start": 66,
+    "line_end": 69,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "3f07497ccd429eea",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "class",
+    "name": "Audited",
+    "scope": "",
+    "language": "java",
+    "content": "/** Marks a greeter method as audited. */\n@interface Audited {\n    String value();\n}",
+    "line_start": 72,
+    "line_end": 75,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  },
+  {
+    "id": "8f7a02443382b322",
+    "blob_sha": "sha1",
+    "file_path": "java.java",
+    "kind": "method",
+    "name": "value",
+    "scope": "Audited",
+    "language": "java",
+    "content": "String value();",
+    "line_start": 74,
+    "line_end": 74,
+    "metadata": {
+      "module": "",
+      "names": "",
+      "dots": "",
+      "language_hint": ""
+    }
+  }
+]

rbtr_lang_java/tests/cases_docstrings.py

@@ -0,0 +1,113 @@
+"""Java 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_java_javadoc_on_class() -> DocstringCase:
+    """Canonical Javadoc above a class declaration."""
+    src = """\
+/** A widget. */
+public class Widget {}
+"""
+    return "java", src, "Widget", "A widget"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_java_javadoc_on_method() -> DocstringCase:
+    """Canonical Javadoc above a method declaration."""
+    src = """\
+public class Widget {
+    /** Render the widget. */
+    public void render() {}
+}
+"""
+    return "java", src, "render", "Render the widget"
+
+
+@case(tags=["documented", "canonical", "exterior_doc"])
+def case_java_multi_line_javadoc_with_tags() -> DocstringCase:
+    """Multi-line Javadoc with `@param` / `@return`."""
+    src = """\
+public class Widget {
+    /**
+     * Compute a hash.
+     * @param data input
+     * @return hex string
+     */
+    public String hash(byte[] data) { return ""; }
+}
+"""
+    return "java", src, "hash", "@return hex string"
+
+
+@case(tags=["documented", "edge_case", "exterior_doc"])
+def case_java_javadoc_above_annotated_method() -> DocstringCase:
+    """Annotations parse as part of the method node's
+    `modifiers` child, so the Javadoc remains the method's
+    `prev_named_sibling` and attaches correctly.
+    """
+    src = """\
+public class Widget {
+    /** Deprecated API. */
+    @Deprecated
+    public void old() {}
+}
+"""
+    return "java", src, "old", "Deprecated API"
+
+
+@case(tags=["documented", "unconventional", "exterior_doc"])
+def case_java_line_comment_run_on_method() -> DocstringCase:
+    """Plain `//` comment run attaches too."""
+    src = """\
+public class C {
+    // A line comment.
+    // Second line.
+    public void m() {}
+}
+"""
+    return "java", src, "m", "A line comment"
+
+
+@case(tags=["undocumented", "no_docs"])
+def case_java_method_without_doc() -> DocstringCase:
+    """Undocumented method."""
+    src = """\
+public class C { public void bare() {} }
+"""
+    return "java", src, "bare", "PHANTOM_DOC_TEXT_SHOULD_NEVER_APPEAR"
+
+
+@case(tags=["undocumented", "boundary_not_attached"])
+def case_java_javadoc_detached_by_blank_line() -> DocstringCase:
+    """Blank line between Javadoc and method breaks attachment."""
+    src = """\
+public class C {
+    /** Orphan. */
+
+    public void later() {}
+}
+"""
+    return "java", src, "later", "Orphan"
+
+
+@case(tags=["undocumented", "invalid"])
+def case_java_javadoc_on_previous_method_does_not_attach_to_later() -> DocstringCase:
+    """A Javadoc above method A is not attached to later method B."""
+    src = """\
+public class C {
+    /** Doc for first. */
+    public void first() {}
+
+    public void second() {}
+}
+"""
+    return "java", src, "second", "Doc for first"

rbtr_lang_java/tests/cases_extraction.py

@@ -0,0 +1,215 @@
+"""Java 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_java_class() -> SymbolCase:
+    """class User {}."""
+    return "java", "class User {}\n", [("class", "User", "")]
+
+
+@case(tags=["symbol"])
+def case_java_public_class() -> SymbolCase:
+    """public class App {}."""
+    return "java", "public class App {}\n", [("class", "App", "")]
+
+
+@case(tags=["symbol"])
+def case_java_class_extends() -> SymbolCase:
+    """class Admin extends User {}."""
+    return "java", "class Admin extends User {}\n", [("class", "Admin", "")]
+
+
+@case(tags=["symbol"])
+def case_java_class_implements() -> SymbolCase:
+    """class UserService implements Service {}."""
+    return "java", "class UserService implements Service {}\n", [("class", "UserService", "")]
+
+
+@case(tags=["symbol"])
+def case_java_multiple_classes() -> SymbolCase:
+    """Multiple classes."""
+    src = """\
+class Foo {}
+class Bar {}
+"""
+    return "java", src, [("class", "Foo", ""), ("class", "Bar", "")]
+
+
+@case(tags=["symbol"])
+def case_java_method_in_class() -> SymbolCase:
+    """Method scoped to class."""
+    src = """\
+class Service {
+    void process() {}
+}
+"""
+    return "java", src, [("method", "process", "Service")]
+
+
+@case(tags=["symbol"])
+def case_java_multiple_methods() -> SymbolCase:
+    """Multiple methods."""
+    src = """\
+class Svc {
+    void start() {}
+    void stop() {}
+}
+"""
+    return "java", src, [("method", "start", "Svc"), ("method", "stop", "Svc")]
+
+
+@case(tags=["symbol"])
+def case_java_static_method() -> SymbolCase:
+    """Static method still scoped."""
+    src = """\
+class Factory {
+    static Object create() { return null; }
+}
+"""
+    return "java", src, [("method", "create", "Factory")]
+
+
+@case(tags=["symbol"])
+def case_java_method_params() -> SymbolCase:
+    """Method with parameters."""
+    src = """\
+class Calc {
+    int add(int a, int b) { return a + b; }
+}
+"""
+    return "java", src, [("method", "add", "Calc")]
+
+
+@case(tags=["symbol"])
+def case_java_nested_class() -> SymbolCase:
+    """Nested class scoped to outer, method scoped to inner."""
+    src = """\
+class Outer {
+    class Inner {
+        void deep() {}
+    }
+}
+"""
+    return (
+        "java",
+        src,
+        [("class", "Outer", ""), ("class", "Inner", "Outer"), ("method", "deep", "Outer::Inner")],
+    )
+
+
+@case(tags=["symbol"])
+def case_java_triple_nested_class() -> SymbolCase:
+    """Three levels of nested class compose the full path."""
+    src = """\
+class Outer {
+    class Mid {
+        class Inner {
+            void deep() {}
+        }
+    }
+}
+"""
+    return "java", src, [("method", "deep", "Outer::Mid::Inner")]
+
+
+@case(tags=["import"])
+def case_java_import_class() -> ImportCase:
+    """import java.util.HashMap."""
+    return "java", "import java.util.HashMap;\n", {"module": "java.util.HashMap"}
+
+
+@case(tags=["import"])
+def case_java_import_deeply_nested() -> ImportCase:
+    """import com.example.app.models.User."""
+    return (
+        "java",
+        "import com.example.app.models.User;\n",
+        {"module": "com.example.app.models.User"},
+    )
+
+
+@case(tags=["import"])
+def case_java_import_static() -> ImportCase:
+    """import static org.junit.Assert.assertEquals."""
+    return (
+        "java",
+        "import static org.junit.Assert.assertEquals;\n",
+        {"module": "org.junit.Assert.assertEquals"},
+    )
+
+
+@case(tags=["import"])
+def case_java_import_static_method() -> ImportCase:
+    """import static java.util.Collections.sort."""
+    return (
+        "java",
+        "import static java.util.Collections.sort;\n",
+        {"module": "java.util.Collections.sort"},
+    )
+
+
+@case(tags=["multi_import"])
+def case_java_multiple_imports() -> MultiImportCase:
+    """Two import statements."""
+    src = """\
+import java.util.List;
+import java.util.Map;
+"""
+    return (
+        "java",
+        src,
+        2,
+        [
+            {"module": "java.util.List"},
+            {"module": "java.util.Map"},
+        ],
+    )
+
+
+@case(tags=["mixed"])
+def case_java_full_class() -> MixedCase:
+    """Realistic Java class with Javadoc on every member.
+
+    Expected tuple unchanged; content assertions in
+    `test_docstrings.py`.
+    """
+    src = """\
+import java.util.List;
+import java.util.ArrayList;
+
+/** Tracks registered user names. */
+public class UserService {
+    private List<String> names;
+
+    /** Append a new name to the registry. */
+    public void addName(String name) {
+        names.add(name);
+    }
+
+    /** Return the current list of names. */
+    public List<String> getNames() {
+        return names;
+    }
+}
+"""
+    return (
+        "java",
+        src,
+        {"import", "class", "method"},
+        [("addName", "UserService"), ("getNames", "UserService")],
+    )

rbtr_lang_java/tests/samples/java/com/example/format/Formatter.java

@@ -0,0 +1,6 @@
+package com.example.format;
+
+/** Formats a greeting for a recipient. */
+public interface Formatter {
+    String format(String name);
+}

rbtr_lang_java/tests/samples/java/java.java

@@ -0,0 +1,75 @@
+// Greeter — format greetings for named recipients.
+//
+// The Java plugin extracts classes, methods (including constructors),
+// fields (as variables), and imports. Interfaces, enums, and records are
+// captured as classes, and their members scope to them.
+package com.example.greet;
+
+import java.util.List;
+import static java.util.Collections.emptyList;
+
+import com.example.format.Formatter;
+
+// Standalone note at top level, separated by blank lines.
+// Second line of the same block.
+
+/** Formats greetings with a configurable prefix. */
+public class Greeter implements Formatter {
+    private final String prefix;
+
+    public Greeter(String prefix) {
+        this.prefix = prefix;
+    }
+
+    /** Format a greeting (implements the Formatter contract). */
+    @Override
+    public String format(String name) {
+        return greet(name);
+    }
+
+    /** Greet a single recipient. */
+    public String greet(String name) {
+        return prefix + ", " + name;
+    }
+
+    /** Build a greeter with the default prefix. */
+    public static Greeter withDefault() {
+        return new Greeter("Hello");
+    }
+
+    /** A nested formatter. */
+    static class Formatter {
+        String format(String name) {
+            return name.trim();
+        }
+    }
+}
+
+/** A greeting strategy contract. */
+interface Strategy {
+    String render(String name);
+}
+
+/** Supported greeting tones. */
+enum Tone {
+    FORMAL,
+    CASUAL;
+
+    /** Human-readable label for this tone. */
+    String label() {
+        return name().toLowerCase();
+    }
+}
+
+/** An immutable named recipient. */
+record Recipient(String name, String locale) {
+    /** Full display name including locale. */
+    String display() {
+        return name + " (" + locale + ")";
+    }
+}
+
+/** Marks a greeter method as audited. */
+@interface Audited {
+    String value();
+}

rbtr_lang_java/tests/test_docstrings.py

@@ -0,0 +1,43 @@
+"""Java doc-comment extraction (Java 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_java/tests/test_extraction.py

@@ -0,0 +1,57 @@
+"""Java 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_java/tests/test_samples.py

@@ -0,0 +1,73 @@
+"""java sample extraction: the `samples/java/` 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" / "java"
+    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 "java"
+        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.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 "java")
+        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_java-2026.7.0.dev0.dist-info/METADATA

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

rbtr_lang_java-2026.7.0.dev0.dist-info/RECORD

@@ -0,0 +1,18 @@
+rbtr_lang_java/__init__.py,sha256=VFKv8iFU-fgKOWo3kiVJPUjKTzJpGOe56eJk-KTsKck,36
+rbtr_lang_java/java.scm,sha256=w-ZXb30NpYY9vEMxhY-Xa1U0Af4UUbd-BegM1r_hv-A,1110
+rbtr_lang_java/plugin.py,sha256=zGIibd6FqhWWzXEMLIFrh-iksWwfAARp0n8IQn4Lg7Y,1604
+rbtr_lang_java/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_java/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rbtr_lang_java/tests/__snapshots__/test_samples/test_edges_match_snapshot.json,sha256=5KJM-lNVfq6Go6vl08c8-bR2BebL_SH0y2iGYDLSLt8,222
+rbtr_lang_java/tests/__snapshots__/test_samples/test_extraction_matches_snapshot.json,sha256=Cq_BNdMgeipaewijIlFYgmeNb5rC0PqGd9p3-sZZj5o,12701
+rbtr_lang_java/tests/cases_docstrings.py,sha256=EtybMdvhrVx-c3eQqDieuSaNz2EIcrTLl9EUOTiRQYQ,2971
+rbtr_lang_java/tests/cases_extraction.py,sha256=EWmf0tZ3AbAkRF6nXsw5_IPTUGkotqWS09BFs1aSkmU,5164
+rbtr_lang_java/tests/samples/java/com/example/format/Formatter.java,sha256=54LpdddqFxN2M7Y3RY_pIDtXdaN_i5-3vvm8pPxDYQM,135
+rbtr_lang_java/tests/samples/java/java.java,sha256=ZwGw2fjqUC33RuPJS2jBLabGYmiAt3AlaiP4gsBOOik,1823
+rbtr_lang_java/tests/test_docstrings.py,sha256=oKBa0Ubvzxh_aiDMX2qvw3PV35sx46wfDBAFN-l6rbg,1752
+rbtr_lang_java/tests/test_extraction.py,sha256=TNRzVn2T0MBtKXck-dvVO5nLUlI5vDCojySyfMhxQQI,2654
+rbtr_lang_java/tests/test_samples.py,sha256=inbDO27F1Ss8KFRIy-yeN6GwAZfNn7n5UbGrJkhF3cY,2272
+rbtr_lang_java-2026.7.0.dev0.dist-info/WHEEL,sha256=CoDSoyhtC_eO_tlxRYzsTraPv1fPJRXFx91k6ISeAvA,81
+rbtr_lang_java-2026.7.0.dev0.dist-info/entry_points.txt,sha256=Uy4x3Y6jW3R6M_VV2bHXgcjs8GiGI-MAYu4wx9agXKg,52
+rbtr_lang_java-2026.7.0.dev0.dist-info/METADATA,sha256=rtkyczRFo3qvFdf1Ig4i6qwpkwBMC8MOZ_EzsFX18Pk,220
+rbtr_lang_java-2026.7.0.dev0.dist-info/RECORD,,

rbtr_lang_java-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_java-2026.7.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[rbtr.languages]
+java = rbtr_lang_java.plugin:java
+