diffninja 0.1.0

package/dist/languages/ruby.js

@@ -0,0 +1,391 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, declaredParamsOf, collapseWs, locFromNode, namedChildren, } from "./types.js";
+function getParamsLabel(params) {
+    if (!params || params.type !== "method_parameters")
+        return "()";
+    const names = [];
+    for (const p of namedChildren(params)) {
+        if (p.type === "identifier" || p.type === "optional_parameter") {
+            const id = p.type === "identifier" ? p : childByType(p, "identifier");
+            names.push(id?.text ?? "_");
+            continue;
+        }
+        if (p.type === "splat_parameter" ||
+            p.type === "hash_splat_parameter" ||
+            p.type === "block_parameter") {
+            const id = childByType(p, "identifier");
+            const prefix = p.type === "hash_splat_parameter"
+                ? "**"
+                : p.type === "block_parameter"
+                    ? "&"
+                    : "*";
+            names.push(id ? `${prefix}${id.text}` : prefix);
+            continue;
+        }
+        if (p.type === "keyword_parameter") {
+            const id = childByType(p, "identifier");
+            names.push(id ? `${id.text}:` : "_:");
+            continue;
+        }
+        names.push("_");
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function callKey(node, className) {
+    // call → [receiver,] identifier/constant, [argument_list|!]
+    const kids = namedChildren(node).filter((c) => c.type !== "argument_list" &&
+        c.type !== "block" &&
+        c.type !== "do_block");
+    if (kids.length === 0)
+        return null;
+    if (kids.length === 1) {
+        const only = kids[0];
+        if (only.type === "identifier") {
+            return className ? `${className}.${only.text}` : only.text;
+        }
+        return null;
+    }
+    const method = kids[kids.length - 1];
+    const receiver = kids[0];
+    if (method.type !== "identifier")
+        return null;
+    const prop = method.text;
+    if (receiver.type === "self" && className) {
+        return `${className}.${prop}`;
+    }
+    if (receiver.type === "constant") {
+        if (prop === "new")
+            return `new ${receiver.text}`;
+        return `${receiver.text}.${prop}`;
+    }
+    if (receiver.type === "identifier") {
+        return `${receiver.text}.${prop}`;
+    }
+    if (className)
+        return `${className}.${prop}`;
+    return prop;
+}
+/**
+ * Bare identifier used as a call (Ruby paren-less style).
+ * Only treat as call when it appears in statement/expression call position.
+ */
+function bareCallKey(node, className) {
+    if (node.type !== "identifier")
+        return null;
+    const name = node.text;
+    // Skip assignment targets handled elsewhere; keywords-ish
+    if (name === "self" || name === "super") {
+        return className && name === "super" ? className : null;
+    }
+    return className ? `${className}.${name}` : name;
+}
+function collectBody(file, body, className) {
+    if (!body)
+        return [];
+    if (body.type === "body_statement" || body.type === "then" || body.type === "else") {
+        return collectStatements(file, namedChildren(body), className);
+    }
+    return collectStatements(file, [body], className);
+}
+function collectStatements(file, statements, className) {
+    const steps = [];
+    const seen = new Set();
+    const addCall = (key, node) => {
+        const mark = `${key}:${node.startIndex}`;
+        if (seen.has(mark))
+            return;
+        seen.add(mark);
+        const step = { type: "call", key, ...locFromNode(file, node) };
+        step.syntax = heuristicCallSyntax(node, key);
+        steps.push(step);
+    };
+    const walk = (node, asStatement) => {
+        if (node.type === "method" ||
+            node.type === "singleton_method" ||
+            node.type === "class" ||
+            node.type === "module" ||
+            node.type === "lambda" ||
+            node.type === "block" ||
+            node.type === "do_block") {
+            return;
+        }
+        if (node.type === "if" || node.type === "unless") {
+            const kids = namedChildren(node);
+            const cond = kids.find((c) => c.type !== "then" &&
+                c.type !== "else" &&
+                c.type !== "elsif") ?? null;
+            const thenNode = childByType(node, "then");
+            const condText = cond ? collapseWs(cond.text) : "";
+            const kind = node.type; // if | unless
+            steps.push({
+                type: "branch",
+                key: condText ? `${kind}:${condText}` : kind,
+                label: condText ? `${kind} ${condText}` : kind,
+                ...locFromNode(file, cond ?? node),
+                children: collectBody(file, thenNode, className),
+            });
+            for (const clause of kids) {
+                if (clause.type === "elsif") {
+                    const elsifKids = namedChildren(clause);
+                    const elsifCond = elsifKids.find((c) => c.type !== "then" && c.type !== "else") ??
+                        null;
+                    const text = elsifCond ? collapseWs(elsifCond.text) : "";
+                    steps.push({
+                        type: "branch",
+                        key: text ? `else-if:${text}` : "else-if",
+                        label: text ? `elsif ${text}` : "elsif",
+                        ...locFromNode(file, elsifCond ?? clause),
+                        children: collectBody(file, childByType(clause, "then"), className),
+                    });
+                    // nested else under elsif
+                    const nestedElse = childByType(clause, "else");
+                    if (nestedElse) {
+                        steps.push({
+                            type: "branch",
+                            key: "else",
+                            label: "else",
+                            ...locFromNode(file, nestedElse),
+                            children: collectBody(file, nestedElse, className),
+                        });
+                    }
+                }
+                if (clause.type === "else") {
+                    steps.push({
+                        type: "branch",
+                        key: "else",
+                        label: "else",
+                        ...locFromNode(file, clause),
+                        children: collectBody(file, clause, className),
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "begin") {
+            // Body statements are direct children before rescue/ensure/else
+            const bodyStmts = namedChildren(node).filter((c) => c.type !== "rescue" &&
+                c.type !== "ensure" &&
+                c.type !== "else");
+            steps.push({
+                type: "branch",
+                key: "try",
+                label: "begin",
+                ...locFromNode(file, node),
+                children: collectStatements(file, bodyStmts, className),
+            });
+            for (const clause of namedChildren(node)) {
+                if (clause.type === "rescue") {
+                    const exceptions = childByType(clause, "exceptions");
+                    const text = exceptions ? collapseWs(exceptions.text) : "";
+                    const thenNode = childByType(clause, "then");
+                    steps.push({
+                        type: "branch",
+                        key: text ? `rescue:${text}` : "rescue",
+                        label: text ? `rescue ${text}` : "rescue",
+                        ...locFromNode(file, exceptions ?? clause),
+                        children: thenNode
+                            ? collectBody(file, thenNode, className)
+                            : collectStatements(file, namedChildren(clause).filter((c) => c.type !== "exceptions" && c.type !== "exception_variable"), className),
+                    });
+                }
+                if (clause.type === "else") {
+                    steps.push({
+                        type: "branch",
+                        key: "else",
+                        label: "else",
+                        ...locFromNode(file, clause),
+                        children: collectBody(file, clause, className),
+                    });
+                }
+                if (clause.type === "ensure") {
+                    steps.push({
+                        type: "branch",
+                        key: "ensure",
+                        label: "ensure",
+                        ...locFromNode(file, clause),
+                        children: collectStatements(file, namedChildren(clause), className),
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "case") {
+            for (const clause of namedChildren(node)) {
+                if (clause.type === "when") {
+                    const pattern = childByType(clause, "pattern") ??
+                        namedChildren(clause).find((c) => c.type !== "then") ??
+                        null;
+                    const text = pattern ? collapseWs(pattern.text) : "";
+                    steps.push({
+                        type: "branch",
+                        key: text ? `when:${text}` : "when",
+                        label: text ? `when ${text}` : "when",
+                        ...locFromNode(file, pattern ?? clause),
+                        children: collectBody(file, childByType(clause, "then"), className),
+                    });
+                }
+                if (clause.type === "else") {
+                    steps.push({
+                        type: "branch",
+                        key: "else",
+                        label: "else",
+                        ...locFromNode(file, clause),
+                        children: collectBody(file, clause, className),
+                    });
+                }
+            }
+            return;
+        }
+        if (node.type === "call") {
+            // Ruby models `obj.attr` as `call` even without args. Count those only
+            // at statement level; always count calls that pass an argument_list.
+            const hasArgs = childByType(node, "argument_list") !== null;
+            const hasBlock = childByType(node, "block") !== null ||
+                childByType(node, "do_block") !== null;
+            const kids = namedChildren(node).filter((c) => c.type !== "argument_list" &&
+                c.type !== "block" &&
+                c.type !== "do_block");
+            const isReceiverCall = kids.length >= 2;
+            // `lambda { ... }` / `proc { ... }` are closures, not real callees
+            const bareName = kids.length === 1 && kids[0].type === "identifier"
+                ? kids[0].text
+                : null;
+            const isClosureCtor = hasBlock && (bareName === "lambda" || bareName === "proc");
+            if (!isClosureCtor &&
+                (asStatement || hasArgs || !isReceiverCall)) {
+                const key = callKey(node, className);
+                if (key)
+                    addCall(key, node);
+            }
+            // Nested invocations inside arguments (not bare attr reads)
+            const args = childByType(node, "argument_list");
+            if (args) {
+                for (const child of namedChildren(args))
+                    walk(child, false);
+            }
+            return;
+        }
+        if (node.type === "assignment") {
+            // RHS may be bare call identifier
+            const kids = namedChildren(node);
+            const rhs = kids[1] ?? null;
+            if (rhs) {
+                if (rhs.type === "identifier") {
+                    // Assignment RHS is a free call, never a receiver method.
+                    const key = bareCallKey(rhs, null);
+                    if (key)
+                        addCall(key, rhs);
+                }
+                else {
+                    walk(rhs, false);
+                }
+            }
+            return;
+        }
+        // Statement-level bare identifier → method call
+        if (node.type === "identifier" && asStatement) {
+            const key = bareCallKey(node, className);
+            if (key)
+                addCall(key, node);
+            return;
+        }
+        for (const child of namedChildren(node)) {
+            walk(child, false);
+        }
+    };
+    for (const stmt of statements)
+        walk(stmt, true);
+    return steps;
+}
+function handleMethod(file, node, className, functions) {
+    const name = childByType(node, "identifier")?.text ?? null;
+    if (!name)
+        return;
+    const params = childByType(node, "method_parameters");
+    const body = childByType(node, "body_statement");
+    const isInit = className !== null && name === "initialize";
+    const key = className
+        ? isInit
+            ? `${className}.initialize`
+            : `${className}.${name}`
+        : name;
+    const labelBase = isInit ? `${className}` : key;
+    const info = {
+        key,
+        label: `${labelBase}${getParamsLabel(params)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps: collectBody(file, body, className),
+        exported: !name.startsWith("_"),
+        start: node.startIndex,
+        end: node.endIndex,
+    };
+    functions.push(info);
+    if (isInit && className) {
+        functions.push({
+            ...info,
+            key: `new ${className}`,
+            label: `${className}${getParamsLabel(params)}`,
+            params: declaredParamsOf(node),
+        });
+    }
+}
+function handleSingletonMethod(file, node, className, functions) {
+    // def self.bar / def Foo.bar
+    const name = childByType(node, "identifier")?.text ?? null;
+    if (!name)
+        return;
+    const params = childByType(node, "method_parameters");
+    const body = childByType(node, "body_statement");
+    const key = className ? `${className}.${name}` : name;
+    functions.push({
+        key,
+        label: `${key}${getParamsLabel(params)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps: collectBody(file, body, className),
+        exported: !name.startsWith("_"),
+        start: node.startIndex,
+        end: node.endIndex,
+    });
+}
+function handleClass(file, node, functions) {
+    const className = childByType(node, "constant")?.text ?? null;
+    if (!className)
+        return;
+    const body = childByType(node, "body_statement");
+    if (!body)
+        return;
+    for (const stmt of namedChildren(body)) {
+        if (stmt.type === "method") {
+            handleMethod(file, stmt, className, functions);
+        }
+        else if (stmt.type === "singleton_method") {
+            handleSingletonMethod(file, stmt, className, functions);
+        }
+        else if (stmt.type === "class") {
+            handleClass(file, stmt, functions);
+        }
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        if (stmt.type === "method") {
+            handleMethod(file, stmt, null, functions);
+        }
+        else if (stmt.type === "singleton_method") {
+            handleSingletonMethod(file, stmt, null, functions);
+        }
+        else if (stmt.type === "class") {
+            handleClass(file, stmt, functions);
+        }
+    }
+    return functions;
+}
+export const rubyExtractor = {
+    id: "ruby",
+    extensions: [".rb"],
+    grammarPackage: "tree-sitter-ruby",
+    extract: extractFromTree,
+};

package/dist/languages/rust.d.ts

@@ -0,0 +1,2 @@
+import { type LanguageExtractor } from "./types.js";
+export declare const rustExtractor: LanguageExtractor;

package/dist/languages/rust.js

@@ -0,0 +1,261 @@
+import { heuristicCallSyntax } from "./call-syntax.js";
+import { childByType, declaredParamsOf, collapseWs, locFromNode, namedChildren, sameNode, } from "./types.js";
+function isPublic(node) {
+    return childByType(node, "visibility_modifier") !== null;
+}
+function getParamsLabel(params) {
+    if (!params || params.type !== "parameters")
+        return "()";
+    const names = [];
+    for (const p of namedChildren(params)) {
+        if (p.type === "self_parameter") {
+            names.push("self");
+            continue;
+        }
+        if (p.type === "parameter") {
+            const ident = namedChildren(p).find((c) => c.type === "identifier") ?? null;
+            names.push(ident?.text ?? "_");
+            continue;
+        }
+        if (p.type === "variadic_parameter") {
+            names.push("...");
+        }
+    }
+    return names.length === 0 ? "()" : `(${names.join(", ")})`;
+}
+function calleeKey(node, typeName) {
+    if (node.type === "identifier")
+        return node.text;
+    if (node.type === "field_expression") {
+        const object = node.namedChild(0);
+        const field = childByType(node, "field_identifier");
+        if (!object || !field)
+            return null;
+        const prop = field.text;
+        if (object.type === "self" && typeName) {
+            return `${typeName}.${prop}`;
+        }
+        if (object.type === "identifier") {
+            const objName = object.text;
+            if (typeName &&
+                objName[0] &&
+                objName[0] === objName[0].toLowerCase()) {
+                return `${typeName}.${prop}`;
+            }
+            return `${objName}.${prop}`;
+        }
+        if (typeName)
+            return `${typeName}.${prop}`;
+        return prop;
+    }
+    if (node.type === "scoped_identifier") {
+        // Foo::new / Foo::bar — last two identifier-like parts
+        const parts = namedChildren(node).filter((c) => c.type === "identifier" ||
+            c.type === "type_identifier" ||
+            c.type === "scoped_identifier");
+        // Flatten: take text of last child as name, preceding type_identifier/identifier
+        const nameNode = parts.at(-1);
+        if (!nameNode)
+            return null;
+        const name = nameNode.text;
+        // Prefer a type_identifier sibling before the name
+        const typeNode = namedChildren(node).find((c) => c.type === "type_identifier") ??
+            namedChildren(node).find((c) => c.type === "identifier" && !sameNode(c, nameNode)) ??
+            null;
+        if (typeNode) {
+            if (name === "new")
+                return `new ${typeNode.text}`;
+            return `${typeNode.text}.${name}`;
+        }
+        return name;
+    }
+    return null;
+}
+function statementsOf(node) {
+    if (node.type === "block")
+        return namedChildren(node);
+    return [node];
+}
+function collectStatements(file, statements, typeName) {
+    const steps = [];
+    const seen = new Set();
+    const addCall = (key, node) => {
+        const mark = `${key}:${node.startIndex}`;
+        if (seen.has(mark))
+            return;
+        seen.add(mark);
+        const step = { type: "call", key, ...locFromNode(file, node) };
+        step.syntax = heuristicCallSyntax(node, key);
+        steps.push(step);
+    };
+    const pushIfChain = (node, asElseIf) => {
+        const kids = namedChildren(node);
+        const cond = kids.find((c) => c.type !== "block" && c.type !== "else_clause") ?? null;
+        const thenBlock = kids.find((c) => c.type === "block") ?? null;
+        const elseClause = childByType(node, "else_clause");
+        const condText = cond ? collapseWs(cond.text) : "";
+        const kind = asElseIf ? "else-if" : "if";
+        const labelKind = asElseIf ? "else if" : "if";
+        steps.push({
+            type: "branch",
+            key: condText ? `${kind}:${condText}` : kind,
+            label: condText ? `${labelKind} ${condText}` : labelKind,
+            ...locFromNode(file, cond ?? node),
+            children: thenBlock
+                ? collectStatements(file, statementsOf(thenBlock), typeName)
+                : [],
+        });
+        if (!elseClause)
+            return;
+        const elseInner = elseClause.namedChild(0);
+        if (!elseInner)
+            return;
+        if (elseInner.type === "if_expression") {
+            pushIfChain(elseInner, true);
+            return;
+        }
+        steps.push({
+            type: "branch",
+            key: "else",
+            label: "else",
+            ...locFromNode(file, elseClause),
+            children: collectStatements(file, statementsOf(elseInner), typeName),
+        });
+    };
+    const walk = (node) => {
+        if (node.type === "function_item" ||
+            node.type === "closure_expression" ||
+            node.type === "impl_item") {
+            return;
+        }
+        if (node.type === "if_expression") {
+            pushIfChain(node, false);
+            return;
+        }
+        if (node.type === "match_expression") {
+            const block = childByType(node, "match_block");
+            for (const arm of block ? namedChildren(block) : []) {
+                if (arm.type !== "match_arm")
+                    continue;
+                const pattern = childByType(arm, "match_pattern") ??
+                    namedChildren(arm).find((c) => c.type !== "block" &&
+                        c.type !== "call_expression" &&
+                        c.type !== "identifier" &&
+                        c.type !== "if_expression" &&
+                        c.type !== "match_expression" &&
+                        c.type !== "closure_expression") ??
+                    null;
+                // Body is the last named child that isn't the pattern / attribute
+                const kids = namedChildren(arm).filter((c) => c.type !== "attribute_item");
+                const body = kids.length > 1 ? kids[kids.length - 1] : null;
+                const text = pattern ? collapseWs(pattern.text) : "";
+                steps.push({
+                    type: "branch",
+                    key: text ? `case:${text}` : "case",
+                    label: text ? `case ${text}` : "case",
+                    ...locFromNode(file, pattern ?? arm),
+                    children: body
+                        ? collectStatements(file, statementsOf(body), typeName)
+                        : [],
+                });
+            }
+            return;
+        }
+        if (node.type === "call_expression") {
+            const callee = node.namedChild(0);
+            if (callee) {
+                const key = calleeKey(callee, typeName);
+                if (key)
+                    addCall(key, node);
+            }
+        }
+        for (const child of namedChildren(node))
+            walk(child);
+    };
+    for (const stmt of statements)
+        walk(stmt);
+    return steps;
+}
+function handleFunctionItem(file, node, typeName, functions) {
+    const name = childByType(node, "identifier")?.text ?? null;
+    if (!name)
+        return;
+    const params = childByType(node, "parameters");
+    const body = childByType(node, "block");
+    const isNew = typeName !== null && name === "new";
+    const key = typeName
+        ? isNew
+            ? `${typeName}.new`
+            : `${typeName}.${name}`
+        : name;
+    const labelBase = isNew ? `new ${typeName}` : key;
+    const exported = isPublic(node) || !name.startsWith("_");
+    const info = {
+        key,
+        label: `${labelBase}${getParamsLabel(params)}`,
+        params: declaredParamsOf(node),
+        file,
+        steps: body ? collectStatements(file, statementsOf(body), typeName) : [],
+        exported,
+        start: node.startIndex,
+        end: node.endIndex,
+    };
+    functions.push(info);
+    if (isNew && typeName) {
+        functions.push({
+            ...info,
+            key: `new ${typeName}`,
+            label: `new ${typeName}${getParamsLabel(params)}`,
+            params: declaredParamsOf(node),
+        });
+    }
+}
+function handleImpl(file, node, functions) {
+    const typeIds = namedChildren(node).filter((c) => c.type === "type_identifier");
+    // `impl Foo` → one type_identifier; `impl Trait for Foo` → last is the type
+    const typeName = typeIds.at(-1)?.text ?? null;
+    if (!typeName)
+        return;
+    const list = childByType(node, "declaration_list");
+    if (!list)
+        return;
+    for (const item of namedChildren(list)) {
+        if (item.type === "function_item") {
+            handleFunctionItem(file, item, typeName, functions);
+        }
+    }
+}
+function handleModule(file, node, functions) {
+    const list = childByType(node, "declaration_list");
+    if (!list)
+        return;
+    for (const item of namedChildren(list)) {
+        visit(file, item, functions);
+    }
+}
+function visit(file, node, functions) {
+    if (node.type === "function_item") {
+        handleFunctionItem(file, node, null, functions);
+        return;
+    }
+    if (node.type === "impl_item") {
+        handleImpl(file, node, functions);
+        return;
+    }
+    if (node.type === "mod_item") {
+        handleModule(file, node, functions);
+    }
+}
+function extractFromTree(file, _source, tree) {
+    const functions = [];
+    for (const stmt of namedChildren(tree.rootNode)) {
+        visit(file, stmt, functions);
+    }
+    return functions;
+}
+export const rustExtractor = {
+    id: "rust",
+    extensions: [".rs"],
+    grammarPackage: "tree-sitter-rust",
+    extract: extractFromTree,
+};

package/dist/languages/scala.d.ts

@@ -0,0 +1,2 @@
+import { type LanguageExtractor } from "./types.js";
+export declare const scalaExtractor: LanguageExtractor;