@optave/codegraph 3.1.4 → 3.2.0

package/src/extractors/ruby.js

@@ -4,211 +4,218 @@ import { findChild, nodeEndLine } from './helpers.js';
  * Extract symbols from Ruby files.
  */
 export function extractRubySymbols(tree, _filePath) {
-  const definitions = [];
-  const calls = [];
-  const imports = [];
-  const classes = [];
-  const exports = [];
+  const ctx = {
+    definitions: [],
+    calls: [],
+    imports: [],
+    classes: [],
+    exports: [],
+  };
 
-  function findRubyParentClass(node) {
-    let current = node.parent;
-    while (current) {
-      if (current.type === 'class') {
-        const nameNode = current.childForFieldName('name');
-        return nameNode ? nameNode.text : null;
-      }
-      if (current.type === 'module') {
-        const nameNode = current.childForFieldName('name');
-        return nameNode ? nameNode.text : null;
-      }
-      current = current.parent;
-    }
-    return null;
+  walkRubyNode(tree.rootNode, ctx);
+  return ctx;
+}
+
+function walkRubyNode(node, ctx) {
+  switch (node.type) {
+    case 'class':
+      handleRubyClass(node, ctx);
+      break;
+    case 'module':
+      handleRubyModule(node, ctx);
+      break;
+    case 'method':
+      handleRubyMethod(node, ctx);
+      break;
+    case 'singleton_method':
+      handleRubySingletonMethod(node, ctx);
+      break;
+    case 'assignment':
+      handleRubyAssignment(node, ctx);
+      break;
+    case 'call':
+      handleRubyCall(node, ctx);
+      break;
   }
 
-  function walkRubyNode(node) {
-    switch (node.type) {
-      case 'class': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const classChildren = extractRubyClassChildren(node);
-          definitions.push({
-            name: nameNode.text,
-            kind: 'class',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: classChildren.length > 0 ? classChildren : undefined,
-          });
-          const superclass = node.childForFieldName('superclass');
-          if (superclass) {
-            // superclass wraps the < token and class name
-            for (let i = 0; i < superclass.childCount; i++) {
-              const child = superclass.child(i);
-              if (child && (child.type === 'constant' || child.type === 'scope_resolution')) {
-                classes.push({
-                  name: nameNode.text,
-                  extends: child.text,
-                  line: node.startPosition.row + 1,
-                });
-                break;
-              }
-            }
-            // Direct superclass node may be a constant
-            if (superclass.type === 'superclass') {
-              for (let i = 0; i < superclass.childCount; i++) {
-                const child = superclass.child(i);
-                if (child && (child.type === 'constant' || child.type === 'scope_resolution')) {
-                  classes.push({
-                    name: nameNode.text,
-                    extends: child.text,
-                    line: node.startPosition.row + 1,
-                  });
-                  break;
-                }
-              }
-            }
-          }
-        }
+  for (let i = 0; i < node.childCount; i++) walkRubyNode(node.child(i), ctx);
+}
+
+// ── Walk-path per-node-type handlers ────────────────────────────────────────
+
+function handleRubyClass(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const classChildren = extractRubyClassChildren(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'class',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: classChildren.length > 0 ? classChildren : undefined,
+  });
+  const superclass = node.childForFieldName('superclass');
+  if (superclass) {
+    for (let i = 0; i < superclass.childCount; i++) {
+      const child = superclass.child(i);
+      if (child && (child.type === 'constant' || child.type === 'scope_resolution')) {
+        ctx.classes.push({
+          name: nameNode.text,
+          extends: child.text,
+          line: node.startPosition.row + 1,
+        });
         break;
       }
-
-      case 'module': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const moduleChildren = extractRubyBodyConstants(node);
-          definitions.push({
+    }
+    if (superclass.type === 'superclass') {
+      for (let i = 0; i < superclass.childCount; i++) {
+        const child = superclass.child(i);
+        if (child && (child.type === 'constant' || child.type === 'scope_resolution')) {
+          ctx.classes.push({
             name: nameNode.text,
-            kind: 'module',
+            extends: child.text,
             line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: moduleChildren.length > 0 ? moduleChildren : undefined,
           });
+          break;
         }
-        break;
       }
+    }
+  }
+}
 
-      case 'method': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const parentClass = findRubyParentClass(node);
-          const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
-          const params = extractRubyParameters(node);
-          definitions.push({
-            name: fullName,
-            kind: 'method',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: params.length > 0 ? params : undefined,
-          });
-        }
-        break;
-      }
+function handleRubyModule(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const moduleChildren = extractRubyBodyConstants(node);
+  ctx.definitions.push({
+    name: nameNode.text,
+    kind: 'module',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: moduleChildren.length > 0 ? moduleChildren : undefined,
+  });
+}
 
-      case 'singleton_method': {
-        const nameNode = node.childForFieldName('name');
-        if (nameNode) {
-          const parentClass = findRubyParentClass(node);
-          const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
-          const params = extractRubyParameters(node);
-          definitions.push({
-            name: fullName,
-            kind: 'function',
-            line: node.startPosition.row + 1,
-            endLine: nodeEndLine(node),
-            children: params.length > 0 ? params : undefined,
-          });
-        }
-        break;
-      }
+function handleRubyMethod(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const parentClass = findRubyParentClass(node);
+  const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+  const params = extractRubyParameters(node);
+  ctx.definitions.push({
+    name: fullName,
+    kind: 'method',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+  });
+}
 
-      case 'assignment': {
-        // Top-level constant assignments (parent is program)
-        if (node.parent && node.parent.type === 'program') {
-          const left = node.childForFieldName('left');
-          if (left && left.type === 'constant') {
-            definitions.push({
-              name: left.text,
-              kind: 'constant',
-              line: node.startPosition.row + 1,
-              endLine: nodeEndLine(node),
-            });
-          }
-        }
-        break;
-      }
+function handleRubySingletonMethod(node, ctx) {
+  const nameNode = node.childForFieldName('name');
+  if (!nameNode) return;
+  const parentClass = findRubyParentClass(node);
+  const fullName = parentClass ? `${parentClass}.${nameNode.text}` : nameNode.text;
+  const params = extractRubyParameters(node);
+  ctx.definitions.push({
+    name: fullName,
+    kind: 'function',
+    line: node.startPosition.row + 1,
+    endLine: nodeEndLine(node),
+    children: params.length > 0 ? params : undefined,
+  });
+}
 
-      case 'call': {
-        const methodNode = node.childForFieldName('method');
-        if (methodNode) {
-          // Check for require/require_relative
-          if (methodNode.text === 'require' || methodNode.text === 'require_relative') {
-            const args = node.childForFieldName('arguments');
-            if (args) {
-              for (let i = 0; i < args.childCount; i++) {
-                const arg = args.child(i);
-                if (arg && (arg.type === 'string' || arg.type === 'string_content')) {
-                  const strContent = arg.text.replace(/^['"]|['"]$/g, '');
-                  imports.push({
-                    source: strContent,
-                    names: [strContent.split('/').pop()],
-                    line: node.startPosition.row + 1,
-                    rubyRequire: true,
-                  });
-                  break;
-                }
-                // Look inside string for string_content
-                if (arg && arg.type === 'string') {
-                  const content = findChild(arg, 'string_content');
-                  if (content) {
-                    imports.push({
-                      source: content.text,
-                      names: [content.text.split('/').pop()],
-                      line: node.startPosition.row + 1,
-                      rubyRequire: true,
-                    });
-                    break;
-                  }
-                }
-              }
-            }
-          } else if (
-            methodNode.text === 'include' ||
-            methodNode.text === 'extend' ||
-            methodNode.text === 'prepend'
-          ) {
-            // Module inclusion — treated like implements
-            const parentClass = findRubyParentClass(node);
-            if (parentClass) {
-              const args = node.childForFieldName('arguments');
-              if (args) {
-                for (let i = 0; i < args.childCount; i++) {
-                  const arg = args.child(i);
-                  if (arg && (arg.type === 'constant' || arg.type === 'scope_resolution')) {
-                    classes.push({
-                      name: parentClass,
-                      implements: arg.text,
-                      line: node.startPosition.row + 1,
-                    });
-                  }
-                }
-              }
-            }
-          } else {
-            const recv = node.childForFieldName('receiver');
-            const call = { name: methodNode.text, line: node.startPosition.row + 1 };
-            if (recv) call.receiver = recv.text;
-            calls.push(call);
-          }
-        }
+function handleRubyAssignment(node, ctx) {
+  if (node.parent && node.parent.type === 'program') {
+    const left = node.childForFieldName('left');
+    if (left && left.type === 'constant') {
+      ctx.definitions.push({
+        name: left.text,
+        kind: 'constant',
+        line: node.startPosition.row + 1,
+        endLine: nodeEndLine(node),
+      });
+    }
+  }
+}
+
+function handleRubyCall(node, ctx) {
+  const methodNode = node.childForFieldName('method');
+  if (!methodNode) return;
+  if (methodNode.text === 'require' || methodNode.text === 'require_relative') {
+    handleRubyRequire(node, ctx);
+  } else if (
+    methodNode.text === 'include' ||
+    methodNode.text === 'extend' ||
+    methodNode.text === 'prepend'
+  ) {
+    handleRubyModuleInclusion(node, methodNode, ctx);
+  } else {
+    const recv = node.childForFieldName('receiver');
+    const call = { name: methodNode.text, line: node.startPosition.row + 1 };
+    if (recv) call.receiver = recv.text;
+    ctx.calls.push(call);
+  }
+}
+
+function handleRubyRequire(node, ctx) {
+  const args = node.childForFieldName('arguments');
+  if (!args) return;
+  for (let i = 0; i < args.childCount; i++) {
+    const arg = args.child(i);
+    if (arg && (arg.type === 'string' || arg.type === 'string_content')) {
+      const strContent = arg.text.replace(/^['"]|['"]$/g, '');
+      ctx.imports.push({
+        source: strContent,
+        names: [strContent.split('/').pop()],
+        line: node.startPosition.row + 1,
+        rubyRequire: true,
+      });
+      break;
+    }
+    if (arg && arg.type === 'string') {
+      const content = findChild(arg, 'string_content');
+      if (content) {
+        ctx.imports.push({
+          source: content.text,
+          names: [content.text.split('/').pop()],
+          line: node.startPosition.row + 1,
+          rubyRequire: true,
+        });
         break;
       }
     }
+  }
+}
 
-    for (let i = 0; i < node.childCount; i++) walkRubyNode(node.child(i));
+function handleRubyModuleInclusion(node, _methodNode, ctx) {
+  const parentClass = findRubyParentClass(node);
+  if (!parentClass) return;
+  const args = node.childForFieldName('arguments');
+  if (!args) return;
+  for (let i = 0; i < args.childCount; i++) {
+    const arg = args.child(i);
+    if (arg && (arg.type === 'constant' || arg.type === 'scope_resolution')) {
+      ctx.classes.push({
+        name: parentClass,
+        implements: arg.text,
+        line: node.startPosition.row + 1,
+      });
+    }
   }
+}
 
-  walkRubyNode(tree.rootNode);
-  return { definitions, calls, imports, classes, exports };
+function findRubyParentClass(node) {
+  let current = node.parent;
+  while (current) {
+    if (current.type === 'class' || current.type === 'module') {
+      const nameNode = current.childForFieldName('name');
+      return nameNode ? nameNode.text : null;
+    }
+    current = current.parent;
+  }
+  return null;
 }
 
 // ── Child extraction helpers ────────────────────────────────────────────────