@untangle-code/parser-registry 0.0.0-stage → 0.1.0

package/src/languages/astgrep-backend/lang/csharp.ts

@@ -0,0 +1,125 @@
+/**
+ * C# (WP-86).
+ *
+ * ABBILDUNGEN: `struct` und `record` -> `class`, `namespace` -> `namespace`.
+ * Eine `property_declaration` (`public string Name { get; set; }`) ist eine
+ * `property`, keine Methode — die Zugriffsmethoden gehoeren zu ihr.
+ *
+ * ENTSCHEIDUNGSPUNKTE (spec.md §16.2/§16.3):
+ *   - `case_switch_label` zaehlt; `default_switch_label` ist eine EIGENE
+ *     Knotenart und steht deshalb gar nicht erst in `caseKinds`.
+ *   - `switch_expression_arm` (C# 8, `x switch { ... }`) zaehlt ebenfalls als
+ *     `case`.
+ *   - `catch_clause` zaehlt, `finally_clause` nicht.
+ *   - `??` zaehlt als `short_circuit`, also NUR erweitert.
+ *   - `?.` (`conditional_access_expression`) zaehlt NICHT. Es verzweigt zwar,
+ *     ist aber in idiomatischem C# die normale Null-Absicherung; klassisch
+ *     mitgezaehlt bekaeme jede defensive Kette dieselbe Zahl wie eine echte
+ *     Fallunterscheidung. Konservative Auslegung, hier benannt.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+
+export const CSHARP_SOURCE: AstGrepLanguageSource = {
+  languageName: "csharp",
+  moduleName: "@ast-grep/lang-csharp",
+};
+
+export const CSHARP_TABLE: LanguageKindTable = {
+  languageId: "csharp",
+  extensions: [".cs"],
+  supportLevel: "deep",
+  commentKinds: ["comment"],
+  stringContainerKinds: [
+    "string_literal",
+    "verbatim_string_literal",
+    "raw_string_literal",
+    "character_literal",
+    "interpolated_string_expression",
+  ],
+  identifierLeafKinds: ["identifier", "predefined_type", "this", "base"],
+  numberLeafKinds: ["integer_literal", "real_literal"],
+  booleanLeafKinds: ["boolean_literal"],
+  nullLeafKinds: ["null_literal"],
+  scopes: [
+    {
+      kinds: ["namespace_declaration", "file_scoped_namespace_declaration"],
+      scopeKind: "namespace",
+    },
+    {
+      kinds: ["class_declaration", "struct_declaration", "record_declaration"],
+      scopeKind: "class",
+    },
+    { kinds: ["interface_declaration"], scopeKind: "interface" },
+    { kinds: ["enum_declaration"], scopeKind: "enum" },
+    { kinds: ["method_declaration"], scopeKind: "method" },
+    { kinds: ["constructor_declaration"], scopeKind: "constructor" },
+    { kinds: ["property_declaration"], scopeKind: "property" },
+    // `field_declaration` hat kein Namensfeld: der Name steht unter
+    // `variable_declaration` -> `variable_declarator`.
+    {
+      kinds: ["field_declaration"],
+      scopeKind: "property",
+      // `field_declaration > variable_declaration > variable_declarator.name`
+      nameKindPath: ["variable_declaration", "variable_declarator"],
+    },
+  ],
+  decisions: {
+    ifKinds: ["if_statement"],
+    elseIfParentKinds: ["if_statement"],
+    loopKinds: ["for_statement", "foreach_statement", "while_statement", "do_statement"],
+    catchKinds: ["catch_clause"],
+    ternaryKinds: ["conditional_expression"],
+    switchKinds: ["switch_statement", "switch_expression"],
+    // Die C#-Grammatik gibt der Marke KEINE eigene Knotenart: `case "a":` und
+    // `default:` sind beide ein `switch_section`, unterschieden nur durch das
+    // Schluesselwortkind. Nachgesehen am Baum von `__golden__/csharp-basic.cs`.
+    caseKinds: ["switch_section", "switch_expression_arm"],
+    caseExcludeChildKinds: ["default"],
+    binaryKinds: ["binary_expression"],
+    operatorField: "operator",
+    logicalAndOperators: ["&&"],
+    logicalOrOperators: ["||"],
+    shortCircuitOperators: ["??"],
+    jumpKinds: ["return_statement", "throw_statement", "break_statement", "continue_statement"],
+    blockKinds: ["block"],
+    consequenceField: "consequence",
+    alternativeField: "alternative",
+  },
+  imports: {
+    kinds: ["using_directive"],
+    // NICHT `name_equals`: bei `using Sys = System.Text;` steht dort der
+    // ALIAS, nicht der Pfad — der Pfad ist der `qualified_name` daneben.
+    pathKinds: ["qualified_name", "identifier"],
+    aliasField: "name",
+  },
+  calls: {
+    kinds: ["invocation_expression"],
+    functionField: "function",
+    argumentsField: "arguments",
+    memberKinds: ["member_access_expression", "qualified_name"],
+    constructionKinds: ["object_creation_expression"],
+    constructedTypeField: "type",
+  },
+  declarationParentKinds: [
+    "class_declaration",
+    "struct_declaration",
+    "record_declaration",
+    "interface_declaration",
+    "enum_declaration",
+    "method_declaration",
+    "constructor_declaration",
+    "property_declaration",
+    "variable_declarator",
+    "parameter",
+    "type_parameter",
+    "catch_declaration",
+    "enum_member_declaration",
+  ],
+  visibilityKinds: ["modifier"],
+  visibilityWords: ["public", "protected", "private", "internal"],
+  bodyField: "body",
+  isExported: (_name, node) =>
+    node.children.some((child) => child.type === "modifier" && child.text === "public"),
+  fieldNames: ["name"],
+};

package/src/languages/astgrep-backend/lang/index.ts

@@ -0,0 +1,61 @@
+/**
+ * Die Sprachen aus WP-86: je EINE Tabelle, kein Motor (vision.md §1b).
+ *
+ * WIE VIEL EINE SPRACHE GEKOSTET HAT, steht in `README.md` neben diesem
+ * Verzeichnis — Zeile fuer Zeile nachgezaehlt. Das ist die Gegenprobe zur
+ * Ratsche: eine Sprache, die 800 Zeilen kostet, waere kein Gewinn gewesen.
+ *
+ * REIHENFOLGE = VERBREITUNG. Sie ist zugleich die Reihenfolge, in der die
+ * Grammatiken registriert werden (`napi.ts`: EIN Aufruf fuer alle).
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+
+import { BASH_SOURCE, BASH_TABLE } from "./bash.js";
+import { C_SOURCE, C_TABLE } from "./c.js";
+import { CPP_SOURCE, CPP_TABLE } from "./cpp.js";
+import { CSHARP_SOURCE, CSHARP_TABLE } from "./csharp.js";
+import { JAVA_SOURCE, JAVA_TABLE } from "./java.js";
+import { KOTLIN_SOURCE, KOTLIN_TABLE } from "./kotlin.js";
+import { PHP_SOURCE, PHP_TABLE } from "./php.js";
+import { RUBY_SOURCE, RUBY_TABLE } from "./ruby.js";
+import { SWIFT_SOURCE, SWIFT_TABLE } from "./swift.js";
+
+/** Eine Sprache: ihre Tabelle und das Paket, aus dem ihre Grammatik kommt. */
+export interface AstGrepLanguage {
+  table: LanguageKindTable;
+  source: AstGrepLanguageSource;
+}
+
+export const AST_GREP_LANGUAGES: readonly AstGrepLanguage[] = [
+  { table: JAVA_TABLE, source: JAVA_SOURCE },
+  { table: CSHARP_TABLE, source: CSHARP_SOURCE },
+  { table: RUBY_TABLE, source: RUBY_SOURCE },
+  { table: PHP_TABLE, source: PHP_SOURCE },
+  { table: KOTLIN_TABLE, source: KOTLIN_SOURCE },
+  { table: C_TABLE, source: C_SOURCE },
+  { table: CPP_TABLE, source: CPP_SOURCE },
+  { table: SWIFT_TABLE, source: SWIFT_SOURCE },
+  { table: BASH_TABLE, source: BASH_SOURCE },
+];
+
+export {
+  BASH_SOURCE,
+  BASH_TABLE,
+  CPP_SOURCE,
+  CPP_TABLE,
+  CSHARP_SOURCE,
+  CSHARP_TABLE,
+  C_SOURCE,
+  C_TABLE,
+  JAVA_SOURCE,
+  JAVA_TABLE,
+  KOTLIN_SOURCE,
+  KOTLIN_TABLE,
+  PHP_SOURCE,
+  PHP_TABLE,
+  RUBY_SOURCE,
+  RUBY_TABLE,
+  SWIFT_SOURCE,
+  SWIFT_TABLE,
+};

package/src/languages/astgrep-backend/lang/java.ts

@@ -0,0 +1,115 @@
+/**
+ * Java (WP-86).
+ *
+ * ABBILDUNGEN auf die Symbolarten aus `shared/scope-model.ts`:
+ * `record` -> `class` (ein benannter Verbund mit Feldern; `ChunkKind` kennt
+ * kein "record"), `@interface` -> `interface`.
+ *
+ * ENTSCHEIDUNGSPUNKTE — die Auslegung, ausdruecklich (spec.md §16.2/§16.3):
+ *   - `switch_label` traegt in DERSELBEN Knotenart sowohl `case X:` als auch
+ *     `default:`. Nur die `case`-Form zaehlt (`caseExcludeChildKinds`). Ein
+ *     `switch` mit drei `case` und einem `default` hat DREI Entscheidungen —
+ *     der Auffangzweig eroeffnet keinen zusaetzlichen unabhaengigen Pfad.
+ *   - `catch_clause` zaehlt als `catch`. `finally_clause` NICHT: es laeuft
+ *     immer und verzweigt nichts.
+ *   - `&&`/`||` zaehlen nur ERWEITERT (§16.3), nie klassisch.
+ *   - `else if` ist in Java ein `if_statement` DIREKT unter einem
+ *     `if_statement` (kein `else_clause`) — `elseIfParentKinds` sagt das.
+ *
+ * NACHGESEHEN, NICHT GERATEN: jede Knotenart hier stammt aus dem Baum von
+ * `__golden__/java-basic.java`, und `golden.test.ts` erzeugt ihn wieder.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+
+export const JAVA_SOURCE: AstGrepLanguageSource = {
+  languageName: "java",
+  moduleName: "@ast-grep/lang-java",
+};
+
+const VISIBILITY_WORDS = ["public", "protected", "private"] as const;
+
+export const JAVA_TABLE: LanguageKindTable = {
+  languageId: "java",
+  extensions: [".java"],
+  supportLevel: "deep",
+  commentKinds: ["line_comment", "block_comment"],
+  stringContainerKinds: ["string_literal", "character_literal", "text_block"],
+  identifierLeafKinds: ["identifier", "type_identifier", "this", "super"],
+  numberLeafKinds: [
+    "decimal_integer_literal",
+    "hex_integer_literal",
+    "octal_integer_literal",
+    "binary_integer_literal",
+    "decimal_floating_point_literal",
+    "hex_floating_point_literal",
+  ],
+  booleanLeafKinds: ["true", "false"],
+  nullLeafKinds: ["null_literal"],
+  scopes: [
+    { kinds: ["class_declaration", "record_declaration"], scopeKind: "class" },
+    {
+      kinds: ["interface_declaration", "annotation_type_declaration"],
+      scopeKind: "interface",
+    },
+    { kinds: ["enum_declaration"], scopeKind: "enum" },
+    { kinds: ["method_declaration"], scopeKind: "method" },
+    { kinds: ["constructor_declaration"], scopeKind: "constructor" },
+    // Der Name eines Feldes steht zwei Ebenen tief:
+    // `field_declaration.declarator` -> `variable_declarator.name`.
+    { kinds: ["field_declaration"], scopeKind: "property", nameField: "declarator.name" },
+  ],
+  decisions: {
+    ifKinds: ["if_statement"],
+    elseIfParentKinds: ["if_statement"],
+    loopKinds: ["for_statement", "enhanced_for_statement", "while_statement", "do_statement"],
+    catchKinds: ["catch_clause"],
+    ternaryKinds: ["ternary_expression"],
+    switchKinds: ["switch_statement", "switch_expression"],
+    caseKinds: ["switch_label"],
+    caseExcludeChildKinds: ["default"],
+    binaryKinds: ["binary_expression"],
+    operatorField: "operator",
+    logicalAndOperators: ["&&"],
+    logicalOrOperators: ["||"],
+    jumpKinds: ["return_statement", "throw_statement", "break_statement", "continue_statement"],
+    blockKinds: ["block"],
+    consequenceField: "consequence",
+    alternativeField: "alternative",
+  },
+  imports: {
+    kinds: ["import_declaration"],
+    // `import_declaration` vergibt keine Feldnamen; der Pfad ist der
+    // `scoped_identifier` darin (bei `import a.*` ein `asterisk` daneben).
+    pathKinds: ["scoped_identifier", "identifier"],
+  },
+  calls: {
+    kinds: ["method_invocation"],
+    functionField: "name",
+    receiverField: "object",
+    argumentsField: "arguments",
+    constructionKinds: ["object_creation_expression"],
+    constructedTypeField: "type",
+  },
+  declarationParentKinds: [
+    "class_declaration",
+    "record_declaration",
+    "interface_declaration",
+    "annotation_type_declaration",
+    "enum_declaration",
+    "method_declaration",
+    "constructor_declaration",
+    "variable_declarator",
+    "formal_parameter",
+    "catch_formal_parameter",
+    "type_parameter",
+    "enum_constant",
+  ],
+  visibilityKinds: ["modifiers"],
+  visibilityWords: [...VISIBILITY_WORDS],
+  bodyField: "body",
+  // Java sagt es mit einem Schluesselwort: `public` in den Modifikatoren.
+  isExported: (_name, node) =>
+    node.children.some((child) => child.type === "modifiers" && /\bpublic\b/.test(child.text)),
+  fieldNames: ["name", "declarator"],
+};

package/src/languages/astgrep-backend/lang/kotlin.ts

@@ -0,0 +1,136 @@
+/**
+ * Kotlin (WP-86).
+ *
+ * DIE BESONDERHEIT, und der Grund fuer jede Eigenart dieser Tabelle: die
+ * Kotlin-Grammatik VERGIBT KEINE FELDNAMEN. Kein `name`, kein `body`, kein
+ * `condition` — nachgesehen an einer echten Datei mit Klasse, Objekt,
+ * Companion, `when`, `try` und Lambda: `node.field(...)` liefert durchweg
+ * `null`. Alles laeuft deshalb ueber `nameKinds`, also ueber die ART des
+ * ersten passenden Kindes.
+ *
+ * ZWEI FOLGEN, die in der Ausgabe sichtbar sind und deshalb hier stehen:
+ *
+ *  1. `normalizedSignature` ist die ERSTE ZEILE des Knotens, nicht der Kopf
+ *     bis zum Rumpf: ohne `body`-Feld gibt es keinen Punkt, an dem der Rumpf
+ *     beginnt (`table-profile.ts#scopeSignature` faellt genau darauf zurueck).
+ *  2. `IdentifierFact.role` ist IMMER `reference`. Die Rolle haengt am
+ *     Feldnamen `name` (`identifierRole`), und den gibt es hier nicht. Eine
+ *     Deklaration von einem Verweis zu unterscheiden waere also geraten —
+ *     lieber eine ehrlich schwaechere Angabe als eine erfundene.
+ *
+ * ABBILDUNGEN: `class_declaration` traegt in Kotlin AUCH `interface`,
+ * `enum class` und `data class`; unterschieden wird ueber das
+ * Schluesselwortkind (`refine`). `object` und `companion object` ->
+ * `namespace` (benannte Singletons, keine Typen).
+ *
+ * ENTSCHEIDUNGSPUNKTE (spec.md §16.2/§16.3):
+ *   - `if_expression` ist Verzweigung UND Ausdruck (Kotlin hat keinen
+ *     Ternaeroperator). Gezaehlt als `if` — dieselbe Zahl unabhaengiger Pfade.
+ *   - `when_entry` ist ein `case`; der `else`-Arm zaehlt nicht
+ *     (`caseExcludeChildKinds: ["else"]`).
+ *   - `catch_block` zaehlt, `finally_block` nicht.
+ *   - `conjunction_expression`/`disjunction_expression` tragen den Operator
+ *     als anonymes Kind statt in einem Feld — `anonymousOperatorKinds`.
+ *   - `elvis_expression` (`a ?: b`) zaehlt als `short_circuit`, nur erweitert.
+ *   - `else if` liegt unter einem `control_structure_body`. Dessen unmittelbar
+ *     vorangehendes anonymes `else`-Geschwister unterscheidet die Fortsetzung
+ *     von einem ungekammerten `if` im Dann-Rumpf (WP-243). Damit bekommt eine
+ *     Kotlin-Kette dieselbe kognitive Verschachtelung wie Java.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+
+export const KOTLIN_SOURCE: AstGrepLanguageSource = {
+  languageName: "kotlin",
+  moduleName: "@ast-grep/lang-kotlin",
+};
+
+export const KOTLIN_TABLE: LanguageKindTable = {
+  languageId: "kotlin",
+  extensions: [".kt", ".kts"],
+  supportLevel: "deep",
+  commentKinds: ["line_comment", "multiline_comment"],
+  stringContainerKinds: ["string_literal", "character_literal"],
+  identifierLeafKinds: ["simple_identifier", "type_identifier", "this", "super"],
+  numberLeafKinds: [
+    "integer_literal",
+    "real_literal",
+    "hex_literal",
+    "bin_literal",
+    "long_literal",
+  ],
+  booleanLeafKinds: ["boolean_literal"],
+  nullLeafKinds: ["null"],
+  scopes: [
+    {
+      kinds: ["class_declaration"],
+      scopeKind: "class",
+      nameKinds: ["type_identifier", "simple_identifier"],
+      refine: [
+        // Reihenfolge zaehlt: `enum class` traegt BEIDE Schluesselwoerter.
+        { childKinds: ["enum"], scopeKind: "enum" },
+        { childKinds: ["interface"], scopeKind: "interface" },
+      ],
+    },
+    {
+      kinds: ["object_declaration"],
+      scopeKind: "namespace",
+      nameKinds: ["type_identifier", "simple_identifier"],
+    },
+    {
+      kinds: ["function_declaration"],
+      scopeKind: "function",
+      nameKinds: ["simple_identifier"],
+    },
+    {
+      kinds: ["property_declaration"],
+      scopeKind: "property",
+      // `property_declaration > variable_declaration > simple_identifier`;
+      // ohne den letzten Schritt stuende `name: String` (mit Typangabe) im
+      // Namen.
+      nameKindPath: ["variable_declaration"],
+      nameKinds: ["simple_identifier"],
+      // NUR auf Klassen-/Dateiebene: `var i = 0` in einem Funktionsrumpf ist
+      // eine lokale Variable und kein Symbol.
+      parentKinds: ["class_body", "enum_class_body", "source_file"],
+    },
+  ],
+  decisions: {
+    ifKinds: ["if_expression"],
+    elseIfWrapperKinds: ["control_structure_body"],
+    // kotlin-tree-sitter 0.0.7 zerlegt ausgerechnet
+    // `else /* Blockkommentar */ if` in Geschwister und verliert das anonyme
+    // `else` aus dem Baum. Der Detektor prueft dafuer den exakt begrenzten
+    // Token-Spalt zwischen diesen Geschwistern; andere Sprachen bleiben aus.
+    recoverDetachedElseIfAfterComments: true,
+    loopKinds: ["for_statement", "while_statement", "do_while_statement"],
+    catchKinds: ["catch_block"],
+    switchKinds: ["when_expression"],
+    caseKinds: ["when_entry"],
+    caseExcludeChildKinds: ["else"],
+    anonymousOperatorKinds: [
+      "conjunction_expression",
+      "disjunction_expression",
+      "elvis_expression",
+    ],
+    logicalAndOperators: ["&&"],
+    logicalOrOperators: ["||"],
+    shortCircuitOperators: ["?:"],
+    jumpKinds: ["jump_expression"],
+    blockKinds: ["control_structure_body", "statements"],
+  },
+  // Kotlin: `import kotlin.math.max` / `import a.b.C as D`. Der Pfad ist das
+  // `identifier`-Kind; der Alias steht in einem `import_alias` daneben.
+  imports: {
+    kinds: ["import_header"],
+    pathKinds: ["identifier"],
+  },
+  calls: {
+    kinds: ["call_expression"],
+    memberKinds: ["navigation_expression"],
+  },
+  declarationParentKinds: [],
+  visibilityKinds: ["modifiers"],
+  visibilityWords: ["public", "internal", "protected", "private"],
+  fieldNames: ["name"],
+};

package/src/languages/astgrep-backend/lang/php.ts

@@ -0,0 +1,105 @@
+/**
+ * PHP (WP-86).
+ *
+ * ABBILDUNGEN: `trait` -> `interface` (ein benannter, wiederverwendbarer Satz
+ * von Methoden ohne eigene Instanz — naeher an einer Schnittstelle als an
+ * einer Klasse), `namespace` -> `namespace`.
+ *
+ * ENTSCHEIDUNGSPUNKTE (spec.md §16.2/§16.3):
+ *   - `else_if_clause` (`elseif`) ist eine EIGENE Knotenart und damit direkt
+ *     ein `else_if`.
+ *   - `case_statement` zaehlt; `default_statement` ist eine eigene Knotenart
+ *     und steht nicht in `caseKinds`.
+ *   - `match_conditional_expression` (PHP 8 `match`) zaehlt als `case`;
+ *     `match_default_expression` nicht.
+ *   - `catch_clause` zaehlt, `finally_clause` nicht.
+ *   - `??` zaehlt als `short_circuit`, nur erweitert. `and`/`or` (die
+ *     niedrigpriorisierten Wortformen) zaehlen wie `&&`/`||`.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+
+export const PHP_SOURCE: AstGrepLanguageSource = {
+  languageName: "php",
+  moduleName: "@ast-grep/lang-php",
+};
+
+export const PHP_TABLE: LanguageKindTable = {
+  languageId: "php",
+  extensions: [".php", ".phtml"],
+  supportLevel: "deep",
+  commentKinds: ["comment"],
+  stringContainerKinds: ["string", "encapsed_string", "heredoc", "nowdoc"],
+  identifierLeafKinds: ["name", "variable_name", "qualified_name", "self", "parent"],
+  numberLeafKinds: ["integer", "float"],
+  booleanLeafKinds: ["boolean"],
+  nullLeafKinds: ["null"],
+  scopes: [
+    { kinds: ["namespace_definition"], scopeKind: "namespace" },
+    { kinds: ["class_declaration"], scopeKind: "class" },
+    { kinds: ["interface_declaration", "trait_declaration"], scopeKind: "interface" },
+    { kinds: ["enum_declaration"], scopeKind: "enum" },
+    {
+      kinds: ["method_declaration"],
+      scopeKind: "method",
+      constructorNames: ["__construct"],
+    },
+    { kinds: ["function_definition"], scopeKind: "function" },
+    {
+      kinds: ["property_declaration"],
+      scopeKind: "property",
+      // `property_declaration > property_element.name`
+      nameKindPath: ["property_element"],
+    },
+  ],
+  decisions: {
+    ifKinds: ["if_statement"],
+    elseIfKinds: ["else_if_clause"],
+    loopKinds: ["for_statement", "foreach_statement", "while_statement", "do_statement"],
+    catchKinds: ["catch_clause"],
+    ternaryKinds: ["conditional_expression"],
+    switchKinds: ["switch_statement", "match_expression"],
+    caseKinds: ["case_statement", "match_conditional_expression"],
+    binaryKinds: ["binary_expression"],
+    operatorField: "operator",
+    logicalAndOperators: ["&&", "and"],
+    logicalOrOperators: ["||", "or"],
+    shortCircuitOperators: ["??"],
+    jumpKinds: ["return_statement", "break_statement", "continue_statement", "throw_expression"],
+    blockKinds: ["compound_statement"],
+    consequenceField: "body",
+    alternativeField: "alternative",
+  },
+  imports: {
+    kinds: ["namespace_use_declaration"],
+    specKinds: ["namespace_use_clause"],
+    pathKinds: ["qualified_name", "name"],
+  },
+  calls: {
+    kinds: ["function_call_expression", "member_call_expression", "scoped_call_expression"],
+    functionField: "name",
+    receiverField: "object",
+    argumentsField: "arguments",
+    constructionKinds: ["object_creation_expression"],
+  },
+  declarationParentKinds: [
+    "class_declaration",
+    "interface_declaration",
+    "trait_declaration",
+    "enum_declaration",
+    "method_declaration",
+    "function_definition",
+    "simple_parameter",
+    "property_element",
+    "const_element",
+  ],
+  visibilityKinds: ["visibility_modifier"],
+  bodyField: "body",
+  isExported: (_name, node) =>
+    !node.children.some(
+      (child) =>
+        child.type === "visibility_modifier" &&
+        (child.text === "private" || child.text === "protected"),
+    ),
+  fieldNames: ["name"],
+};

package/src/languages/astgrep-backend/lang/ruby.ts

@@ -0,0 +1,105 @@
+/**
+ * Ruby (WP-86).
+ *
+ * ABBILDUNGEN: `module` -> `namespace`, `class` -> `class`, `def` und
+ * `def self.x` -> `method`.
+ *
+ * KEINE SICHTBARKEIT. Rubys `private`/`public` sind AUFRUFE, die den Rest des
+ * Klassenrumpfes umschalten — sie stehen nicht am Symbol. Ohne Datenflussblick
+ * ist die Sichtbarkeit eines `def` aus dem Syntaxbaum nicht ablesbar, also
+ * meldet dieser Adapter KEINE statt einer geratenen. Dasselbe gilt fuer
+ * `exportedNames`.
+ *
+ * ENTSCHEIDUNGSPUNKTE (spec.md §16.2/§16.3):
+ *   - Die NACHSTELLFORMEN zaehlen mit: `return x if y` (`if_modifier`) hat
+ *     genau die zwei Pfade, die `if y then return x end` auch haette. Ebenso
+ *     `unless_modifier`, `while_modifier`, `until_modifier`.
+ *   - `elsif` ist eine EIGENE Knotenart und damit direkt ein `else_if`
+ *     (Fortsetzung, kein voller Nesting-Zuwachs).
+ *   - `when` und `in_clause` (Ruby 3 `case/in`) sind `case`-Zweige. Der
+ *     `else`-Zweig eines `case` ist die Knotenart `else` und steht nicht in
+ *     `caseKinds` — er zaehlt also nicht.
+ *   - `rescue` zaehlt als `catch`; `ensure` nicht (laeuft immer).
+ *   - `and`/`or` sind Rubys Wortformen und zaehlen wie `&&`/`||`.
+ *   - `&.` zaehlt NICHT: es ist das `operator`-Feld eines gewoehnlichen
+ *     `call`, und jede Kette wuerde sonst zur Verzweigung.
+ *
+ * IMPORTE: Ruby hat keine. `require`/`require_relative` sind gewoehnliche
+ * Methodenaufrufe — hier NICHT als Import gemeldet, weil die Tabelle sie nicht
+ * vom gleichnamigen Aufruf einer eigenen Methode unterscheiden koennte. Die
+ * Datei meldet also KEINE Importe statt moeglicherweise falscher. Wer sie
+ * braucht, sieht sie in `extractCalls` als Aufrufe von `require`.
+ */
+import type { LanguageKindTable } from "../../shared/table-profile.js";
+import type { AstGrepLanguageSource } from "../adapter.js";
+
+export const RUBY_SOURCE: AstGrepLanguageSource = {
+  languageName: "ruby",
+  moduleName: "@ast-grep/lang-ruby",
+};
+
+export const RUBY_TABLE: LanguageKindTable = {
+  languageId: "ruby",
+  extensions: [".rb", ".rake", ".gemspec"],
+  supportLevel: "deep",
+  commentKinds: ["comment"],
+  stringContainerKinds: ["string", "string_array", "symbol_array", "regex", "heredoc_body"],
+  identifierLeafKinds: [
+    "identifier",
+    "constant",
+    "instance_variable",
+    "class_variable",
+    "global_variable",
+    "simple_symbol",
+    "hash_key_symbol",
+    "self",
+  ],
+  numberLeafKinds: ["integer", "float"],
+  booleanLeafKinds: ["true", "false"],
+  nullLeafKinds: ["nil"],
+  scopes: [
+    { kinds: ["module"], scopeKind: "namespace" },
+    { kinds: ["class", "singleton_class"], scopeKind: "class" },
+    {
+      kinds: ["method", "singleton_method"],
+      scopeKind: "method",
+      constructorNames: ["initialize"],
+    },
+  ],
+  decisions: {
+    ifKinds: ["if", "unless", "if_modifier", "unless_modifier"],
+    elseIfKinds: ["elsif"],
+    loopKinds: ["while", "until", "while_modifier", "until_modifier", "for"],
+    catchKinds: ["rescue", "rescue_modifier"],
+    ternaryKinds: ["ternary"],
+    switchKinds: ["case", "case_match"],
+    caseKinds: ["when", "in_clause"],
+    binaryKinds: ["binary"],
+    operatorField: "operator",
+    logicalAndOperators: ["&&", "and"],
+    logicalOrOperators: ["||", "or"],
+    jumpKinds: ["return", "break", "next", "redo", "retry"],
+    blockKinds: ["then", "body_statement"],
+    consequenceField: "consequence",
+    alternativeField: "alternative",
+  },
+  // Ruby hat keine Importanweisung — siehe Modulkopf.
+  imports: { kinds: [] },
+  calls: {
+    kinds: ["call"],
+    functionField: "method",
+    receiverField: "receiver",
+    argumentsField: "arguments",
+  },
+  declarationParentKinds: [
+    "method",
+    "singleton_method",
+    "class",
+    "module",
+    "optional_parameter",
+    "keyword_parameter",
+    "block_parameter",
+  ],
+  bodyField: "body",
+  fieldNames: ["name"],
+};