@mrclrchtr/supi-tree-sitter 4.1.0 → 4.3.0

package/src/tool/outline-scripting.ts

@@ -0,0 +1,307 @@
+import { nodeToRange } from "../coordinates.ts";
+import type { SyntaxNodeLike } from "../syntax-node.ts";
+import type { OutlineItem } from "../types.ts";
+
+/** Extract Ruby, shell, and R declarations from their grammar-specific node shapes. */
+export function extractScriptingOutlineItems(
+  node: SyntaxNodeLike,
+  source: string,
+): OutlineItem[] | undefined {
+  const ruby = rubyItems(node, "top-level", source);
+  if (ruby) return ruby;
+
+  switch (node.type) {
+    case "variable_assignment":
+      return isNestedShellDeclaration(node) || node.parent?.type === "command"
+        ? []
+        : one(shellVariable(node, "variable", source));
+    case "declaration_command":
+      return isNestedShellDeclaration(node) ? [] : shellDeclarations(node, source);
+    case "function_definition": {
+      const nameType = node.childForFieldName("name")?.type;
+      if (nameType === "word") {
+        return isNestedShellDeclaration(node) ? [] : one(named(node, "function", source));
+      }
+      return nameType === "function" || nameType === "\\" ? [] : undefined;
+    }
+    case "binary_operator":
+      return rAssignments(node, source);
+    default:
+      return undefined;
+  }
+}
+
+function rubyItems(
+  node: SyntaxNodeLike,
+  context: "top-level" | "member",
+  source: string,
+): OutlineItem[] | undefined {
+  switch (node.type) {
+    case "assignment":
+    case "operator_assignment":
+      return rubyAssignments(node, context, source);
+    case "module":
+      return isRubyContainer(node) ? one(rubyContainer(node, "module", source)) : undefined;
+    case "class":
+      return isRubyContainer(node) ? one(rubyContainer(node, "class", source)) : undefined;
+    case "method":
+      return one(named(node, context === "member" ? "method" : "function", source));
+    case "singleton_method":
+      return one(named(node, "method", source));
+    case "singleton_class":
+      return rubyMembers(node.childForFieldName("body"), source);
+    case "alias":
+      return one(named(node, context === "member" ? "method" : "function", source));
+    case "call":
+      return context === "member" ? rubyCallMethods(node, source) : undefined;
+    case "block":
+      return node.childForFieldName("body")?.type === "block_body" ? [] : undefined;
+    case "do_block":
+      return node.childForFieldName("body")?.type === "body_statement" ? [] : undefined;
+    default:
+      return undefined;
+  }
+}
+
+function isRubyContainer(node: SyntaxNodeLike): boolean {
+  const name = node.childForFieldName("name");
+  const body = node.childForFieldName("body");
+  return Boolean(
+    name && RUBY_CONTAINER_NAME_TYPES.has(name.type) && (!body || body.type === "body_statement"),
+  );
+}
+
+function rubyContainer(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  if (!name) return null;
+  return {
+    name: name.text,
+    kind,
+    range: nodeToRange(node, source),
+    children: rubyMembers(node.childForFieldName("body"), source),
+  };
+}
+
+function rubyMembers(body: SyntaxNodeLike | null | undefined, source: string): OutlineItem[] {
+  if (!body) return [];
+  return body.children.flatMap((child) => rubyItems(child, "member", source) ?? []);
+}
+
+function rubyAssignments(
+  node: SyntaxNodeLike,
+  context: "top-level" | "member",
+  source: string,
+): OutlineItem[] {
+  const left = node.childForFieldName("left");
+  if (!left) return [];
+  const range = nodeToRange(node, source);
+  const items = rubyBindingNodes(left)
+    .filter((binding) => context === "top-level" || binding.type !== "identifier")
+    .map((binding) => ({
+      name: binding.text,
+      kind:
+        binding.type === "constant" || binding.type === "scope_resolution"
+          ? "constant"
+          : "variable",
+      range,
+    }));
+  const right = unwrapParentheses(node.childForFieldName("right"));
+  const chained =
+    right?.type === "assignment" || right?.type === "operator_assignment"
+      ? rubyAssignments(right, context, source)
+      : [];
+  return [...items, ...chained];
+}
+
+function rubyBindingNodes(node: SyntaxNodeLike): SyntaxNodeLike[] {
+  if (RUBY_BINDING_TYPES.has(node.type)) return [node];
+  if (!RUBY_BINDING_PATTERNS.has(node.type)) return [];
+  return node.children.flatMap(rubyBindingNodes);
+}
+
+function rubyCallMethods(node: SyntaxNodeLike, source: string): OutlineItem[] | undefined {
+  const method = node.childForFieldName("method")?.text;
+  const argumentsNode = node.childForFieldName("arguments");
+  if (!method || !argumentsNode || node.childForFieldName("receiver")) return undefined;
+
+  if (RUBY_ATTRIBUTE_METHODS.has(method)) {
+    const range = nodeToRange(node, source);
+    return rubySymbolNames(argumentsNode).flatMap((name) => {
+      if (method === "attr_writer") return [{ name: `${name}=`, kind: "method", range }];
+      if (method === "attr_accessor") {
+        return [
+          { name, kind: "method", range },
+          { name: `${name}=`, kind: "method", range },
+        ];
+      }
+      return [{ name, kind: "method", range }];
+    });
+  }
+  if (method === "alias_method") {
+    const name = rubySymbolNames(argumentsNode)[0];
+    return name ? [{ name, kind: "method", range: nodeToRange(node, source) }] : [];
+  }
+  if (RUBY_VISIBILITY_METHODS.has(method)) {
+    const declaration = argumentsNode.children.find(
+      (child) => child.type === "method" || child.type === "singleton_method",
+    );
+    return declaration ? rubyItems(declaration, "member", source) : [];
+  }
+  return undefined;
+}
+
+function rubySymbolNames(node: SyntaxNodeLike): string[] {
+  return node.children
+    .filter((child) => child.type === "simple_symbol")
+    .map((child) => child.text.replace(/^:/, ""));
+}
+
+function isNestedShellDeclaration(node: SyntaxNodeLike): boolean {
+  if (isBackgroundedShellNode(node)) return true;
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    if (SHELL_SCOPE_BOUNDARIES.has(parent.type)) return true;
+  }
+  return false;
+}
+
+function isBackgroundedShellNode(node: SyntaxNodeLike): boolean {
+  for (let current = node, parent = node.parent; parent; current = parent, parent = parent.parent) {
+    const index = parent.children.findIndex((child) => sameNode(child, current));
+    if (index >= 0 && parent.children[index + 1]?.type === "&") return true;
+  }
+  return false;
+}
+
+function sameNode(left: SyntaxNodeLike, right: SyntaxNodeLike): boolean {
+  return (
+    left.type === right.type &&
+    left.startPosition.row === right.startPosition.row &&
+    left.startPosition.column === right.startPosition.column &&
+    left.endPosition.row === right.endPosition.row &&
+    left.endPosition.column === right.endPosition.column
+  );
+}
+
+function shellVariable(
+  node: SyntaxNodeLike,
+  kind: "constant" | "variable",
+  source: string,
+): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  return name?.type === "variable_name"
+    ? { name: name.text, kind, range: nodeToRange(node, source) }
+    : null;
+}
+
+function shellDeclarations(node: SyntaxNodeLike, source: string): OutlineItem[] {
+  if (node.children.some((child) => child.type === "word" && /^-[a-z]*[pf]/i.test(child.text))) {
+    return [];
+  }
+  const constant =
+    node.children.some((child) => child.type === "readonly") ||
+    node.children.some((child) => child.type === "word" && /^-[a-z]*r/i.test(child.text));
+  const range = nodeToRange(node, source);
+  return node.children.flatMap((child) => {
+    if (child.type === "variable_assignment") {
+      const item = shellVariable(child, constant ? "constant" : "variable", source);
+      return item ? [{ ...item, range }] : [];
+    }
+    return child.type === "variable_name"
+      ? [{ name: child.text, kind: constant ? "constant" : "variable", range }]
+      : [];
+  });
+}
+
+function rAssignments(node: SyntaxNodeLike, source: string): OutlineItem[] | undefined {
+  const operator = node.children.find((child) => R_ASSIGNMENT_OPERATORS.has(child.type))?.type;
+  if (!operator) return undefined;
+
+  const leftward = operator === "=" || operator.endsWith("<-");
+  const receiver = node.childForFieldName(leftward ? "lhs" : "rhs");
+  const value = node.childForFieldName(leftward ? "rhs" : "lhs");
+  if (!receiver || !value) return [];
+
+  const item =
+    receiver.type === "identifier"
+      ? [
+          {
+            name: receiver.text,
+            kind: rAssignedValue(value)?.type === "function_definition" ? "function" : "variable",
+            range: nodeToRange(node, source),
+          },
+        ]
+      : [];
+  const nestedAssignment = unwrapParentheses(value);
+  const chained =
+    nestedAssignment?.type === "binary_operator"
+      ? (rAssignments(nestedAssignment, source) ?? [])
+      : [];
+  return [...item, ...chained];
+}
+
+function unwrapParentheses(node: SyntaxNodeLike | null): SyntaxNodeLike | null {
+  if (node?.type === "parenthesized_expression") {
+    return unwrapParentheses(node.childForFieldName("body"));
+  }
+  if (node?.type === "parenthesized_statements") {
+    return unwrapParentheses(
+      node.children.find(
+        (child) => child.type === "assignment" || child.type === "operator_assignment",
+      ) ?? null,
+    );
+  }
+  return node;
+}
+
+function rAssignedValue(node: SyntaxNodeLike): SyntaxNodeLike | null {
+  const assignment = unwrapParentheses(node);
+  if (assignment?.type !== "binary_operator") return assignment;
+
+  const operator = assignment.children.find((child) =>
+    R_ASSIGNMENT_OPERATORS.has(child.type),
+  )?.type;
+  if (!operator) return assignment;
+  const leftward = operator === "=" || operator.endsWith("<-");
+  const value = assignment.childForFieldName(leftward ? "rhs" : "lhs");
+  return value ? rAssignedValue(value) : null;
+}
+
+function one(item: OutlineItem | null): OutlineItem[] {
+  return item ? [item] : [];
+}
+
+function named(node: SyntaxNodeLike, kind: string, source: string): OutlineItem | null {
+  const name = node.childForFieldName("name");
+  return name ? { name: name.text, kind, range: nodeToRange(node, source) } : null;
+}
+
+const RUBY_BINDING_TYPES = new Set([
+  "constant",
+  "identifier",
+  "global_variable",
+  "class_variable",
+  "instance_variable",
+  "scope_resolution",
+]);
+const RUBY_BINDING_PATTERNS = new Set([
+  "left_assignment_list",
+  "destructured_left_assignment",
+  "rest_assignment",
+]);
+const RUBY_CONTAINER_NAME_TYPES = new Set(["constant", "scope_resolution"]);
+const RUBY_ATTRIBUTE_METHODS = new Set(["attr", "attr_reader", "attr_writer", "attr_accessor"]);
+const RUBY_VISIBILITY_METHODS = new Set([
+  "private",
+  "protected",
+  "public",
+  "module_function",
+  "private_class_method",
+  "public_class_method",
+]);
+const SHELL_SCOPE_BOUNDARIES = new Set([
+  "command_substitution",
+  "process_substitution",
+  "subshell",
+  "pipeline",
+]);
+const R_ASSIGNMENT_OPERATORS = new Set(["=", "<-", "<<-", "->", "->>"]);

package/src/tool/outline.ts

@@ -3,6 +3,7 @@
 import { nodeToRange } from "../coordinates.ts";
 import type { SyntaxNodeLike } from "../syntax-node.ts";
 import type { OutlineItem } from "../types.ts";
+import { extractPolyglotOutlineItems } from "./outline-polyglot.ts";
 
 /** Node types that can be extracted directly as outline items. */
 const OUTLINE_DECLARATION_NODE_TYPES = new Set([
@@ -32,12 +33,15 @@ function collectItems(node: SyntaxNodeLike, source: string): OutlineItem[] {
   const items: OutlineItem[] = [];
 
   for (const child of node.children) {
-    const item = extractItem(child, source);
-    if (item) {
-      items.push(item);
-    } else {
-      items.push(...collectItems(child, source));
+    const polyglotItems = extractPolyglotOutlineItems(child, source);
+    if (polyglotItems) {
+      items.push(...polyglotItems);
+      continue;
     }
+
+    const item = extractItem(child, source);
+    if (item) items.push(item);
+    else items.push(...collectItems(child, source));
   }
 
   return items;

package/src/types.ts

@@ -79,7 +79,10 @@ export interface TreeSitterService {
   canParse(file: string): Promise<TreeSitterResult<{ file: string; language: string }>>;
   /** Run a Tree-sitter query and return all captures. */
   query(file: string, queryString: string): Promise<TreeSitterResult<QueryCapture[]>>;
-  /** Extract top-level declarations plus supported class/interface/enum members. */
+  /**
+   * Extract shallow declarations, including supported nested code members,
+   * HTML ids, and SQL schema members.
+   */
   outline(file: string): Promise<TreeSitterResult<OutlineItem[]>>;
   /** Extract static ES import declarations. */
   imports(file: string): Promise<TreeSitterResult<ImportRecord[]>>;
@@ -143,7 +146,6 @@ export type SupportedExtension =
   | ".pyi"
   | ".rs"
   | ".go"
-  | ".mod"
   | ".c"
   | ".h"
   | ".cpp"
@@ -157,9 +159,11 @@ export type SupportedExtension =
   | ".kt"
   | ".kts"
   | ".rb"
+  | ".gemspec"
   | ".sh"
   | ".bash"
   | ".zsh"
+  | ".ksh"
   | ".html"
   | ".htm"
   | ".xhtml"