universal-ast-mapper 2.0.0 → 2.0.1

package/dist/extractors/ruby.js

@@ -0,0 +1,146 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol } from "./common.js";
+// ─── Ruby extractor (tree-sitter-ruby) ────────────────────────────────────────
+// Tracks `private` / `protected` visibility sections inside class bodies.
+export function extractRuby(root, _source) {
+    return collect(namedChildren(root), false);
+}
+function collect(nodes, insideClass) {
+    const out = [];
+    let visibility = "public";
+    for (const n of nodes) {
+        // Bare `private` / `protected` / `public` switches the section.
+        if (n.type === "identifier") {
+            if (n.text === "private" || n.text === "protected")
+                visibility = "private";
+            else if (n.text === "public")
+                visibility = "public";
+            continue;
+        }
+        const sym = handle(n, insideClass, visibility);
+        if (sym)
+            out.push(sym);
+    }
+    return out;
+}
+function bodyOf(node) {
+    const byField = node.childForFieldName("body");
+    if (byField)
+        return byField;
+    for (const c of namedChildren(node)) {
+        if (c.type === "body_statement")
+            return c;
+    }
+    return null;
+}
+function handle(node, insideClass, visibility) {
+    switch (node.type) {
+        case "class": {
+            const body = bodyOf(node);
+            return makeSymbol({
+                name: nameOf(node) ?? "(class)",
+                kind: "class",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "module": {
+            const body = bodyOf(node);
+            return makeSymbol({
+                name: nameOf(node) ?? "(module)",
+                kind: "namespace",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "method": {
+            const body = bodyOf(node);
+            const name = nameOf(node) ?? "(method)";
+            return makeSymbol({
+                name,
+                kind: insideClass ? "method" : "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                visibility,
+                exported: visibility === "public",
+                doc: leadingComment(node),
+            });
+        }
+        case "singleton_method": {
+            const body = bodyOf(node);
+            const name = nameOf(node) ?? "(method)";
+            return makeSymbol({
+                name: `self.${name}`,
+                kind: insideClass ? "method" : "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                visibility,
+                exported: visibility === "public",
+                doc: leadingComment(node),
+            });
+        }
+        case "assignment": {
+            // Top-level / class-level CONSTANT = ...
+            const left = namedChildren(node)[0];
+            if (left?.type === "constant") {
+                return makeSymbol({
+                    name: left.text,
+                    kind: "const",
+                    node,
+                    rawKind: node.type,
+                });
+            }
+            return null;
+        }
+        default:
+            return null;
+    }
+}
+// ─── Import extraction ────────────────────────────────────────────────────────
+// `require 'x'` (external) and `require_relative './x'` (relative).
+export function extractImportsRuby(root, _source) {
+    const imports = [];
+    for (const n of namedChildren(root))
+        collectRequire(n, imports, 0);
+    return imports;
+}
+function collectRequire(node, out, depth) {
+    if (depth > 3)
+        return;
+    if (node.type === "call") {
+        const fn = namedChildren(node)[0];
+        if (fn?.type === "identifier" && (fn.text === "require" || fn.text === "require_relative")) {
+            const args = node.childForFieldName("arguments") ?? findArgs(node);
+            const str = args ? firstString(args) : null;
+            if (str) {
+                const from = fn.text === "require_relative" && !str.startsWith(".") ? `./${str}` : str;
+                out.push({ symbol: "*", from, isSideEffect: true });
+            }
+            return;
+        }
+    }
+    for (const c of namedChildren(node))
+        collectRequire(c, out, depth + 1);
+}
+function findArgs(node) {
+    for (const c of namedChildren(node))
+        if (c.type === "argument_list")
+            return c;
+    return null;
+}
+function firstString(args) {
+    for (const c of namedChildren(args)) {
+        if (c.type === "string") {
+            return c.text.replace(/^['"]|['"]$/g, "");
+        }
+    }
+    return null;
+}

package/dist/extractors/rust.js

@@ -0,0 +1,249 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol } from "./common.js";
+/* ─── helpers ─────────────────────────────────────────────────────────────── */
+function childOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === type)
+            return c;
+    }
+    return null;
+}
+/** Rust: `pub`, `pub(crate)`, ... = public; anything else = module-private. */
+function isPub(node) {
+    const vis = childOfType(node, "visibility_modifier");
+    return !!vis && vis.text.startsWith("pub");
+}
+function vis(node) {
+    return isPub(node) ? "public" : "private";
+}
+/* ─── import extraction ───────────────────────────────────────────────────── */
+export function extractImportsRust(root, _source) {
+    const out = [];
+    for (const child of namedChildren(root)) {
+        if (child.type === "use_declaration") {
+            const arg = child.namedChild(0);
+            if (arg)
+                resolveUse(arg, "", out);
+        }
+    }
+    return out;
+}
+function resolveUse(node, prefix, out) {
+    switch (node.type) {
+        case "identifier":
+        case "type_identifier":
+            out.push({ symbol: node.text, from: join(prefix, node.text) });
+            return;
+        case "scoped_identifier": {
+            const full = node.text;
+            const sym = full.split("::").pop() ?? full;
+            out.push({ symbol: sym, from: full });
+            return;
+        }
+        case "use_as_clause": {
+            const path = node.namedChild(0);
+            const alias = node.namedChild(1);
+            const full = path ? path.text : "";
+            const sym = full.split("::").pop() ?? full;
+            out.push({ symbol: sym, from: full, alias: alias?.text });
+            return;
+        }
+        case "use_wildcard": {
+            const path = node.namedChild(0);
+            out.push({ symbol: "*", from: path ? path.text : prefix, isNamespaceImport: true });
+            return;
+        }
+        case "scoped_use_list": {
+            const base = node.namedChild(0);
+            const list = childOfType(node, "use_list");
+            const newPrefix = base ? base.text : prefix;
+            if (list) {
+                for (const item of namedChildren(list))
+                    resolveUse(item, newPrefix, out);
+            }
+            return;
+        }
+        case "use_list":
+            for (const item of namedChildren(node))
+                resolveUse(item, prefix, out);
+            return;
+        default:
+            return;
+    }
+}
+function join(prefix, name) {
+    return prefix ? `${prefix}::${name}` : name;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractRust(root, _source) {
+    return collect(namedChildren(root));
+}
+function collect(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n);
+        if (Array.isArray(res))
+            out.push(...res);
+        else if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node) {
+    switch (node.type) {
+        case "struct_item": {
+            const name = nameOf(node) ?? "(struct)";
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "struct",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+                children: body && body.type === "field_declaration_list" ? structFields(body) : [],
+            });
+        }
+        case "trait_item": {
+            const name = nameOf(node) ?? "(trait)";
+            const body = node.childForFieldName("body");
+            return makeSymbol({
+                name,
+                kind: "interface",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+                children: body ? traitMethods(body) : [],
+            });
+        }
+        case "enum_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(enum)",
+                kind: "enum",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+            });
+        case "function_item": {
+            const name = nameOf(node) ?? "(fn)";
+            return makeSymbol({
+                name,
+                kind: "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("body")),
+                visibility: vis(node),
+                exported: isPub(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "impl_item": {
+            // Surface impl methods as `Type::method` so the association is visible.
+            const typeNode = node.childForFieldName("type");
+            const typeName = typeNode ? typeNode.text : "";
+            const body = node.childForFieldName("body");
+            const out = [];
+            if (body) {
+                for (const m of namedChildren(body)) {
+                    if (m.type !== "function_item")
+                        continue;
+                    const mName = nameOf(m) ?? "(fn)";
+                    out.push(makeSymbol({
+                        name: typeName ? `${typeName}::${mName}` : mName,
+                        kind: "method",
+                        node: m,
+                        rawKind: m.type,
+                        signature: headerSignature(m, m.childForFieldName("body")),
+                        visibility: vis(m),
+                        exported: isPub(m),
+                        doc: leadingComment(m),
+                    }));
+                }
+            }
+            return out;
+        }
+        case "const_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(const)",
+                kind: "const",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("value")),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "static_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(static)",
+                kind: "var",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, node.childForFieldName("value")),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "type_item":
+            return makeSymbol({
+                name: nameOf(node) ?? "(type)",
+                kind: "type",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, null),
+                visibility: vis(node),
+                exported: isPub(node),
+            });
+        case "mod_item": {
+            // Flatten module contents to the top level.
+            const body = node.childForFieldName("body");
+            return body ? collect(namedChildren(body)) : null;
+        }
+        default:
+            return null;
+    }
+}
+function structFields(list) {
+    const out = [];
+    for (const field of namedChildren(list)) {
+        if (field.type !== "field_declaration")
+            continue;
+        const name = nameOf(field);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "field",
+            node: field,
+            rawKind: field.type,
+            signature: field.text.replace(/\s+/g, " ").trim(),
+            visibility: vis(field),
+            exported: isPub(field),
+        }));
+    }
+    return out;
+}
+function traitMethods(body) {
+    const out = [];
+    for (const m of namedChildren(body)) {
+        if (m.type !== "function_signature_item" && m.type !== "function_item")
+            continue;
+        const name = nameOf(m);
+        if (!name)
+            continue;
+        out.push(makeSymbol({
+            name,
+            kind: "method",
+            node: m,
+            rawKind: m.type,
+            signature: headerSignature(m, m.childForFieldName("body")),
+            visibility: "public",
+            exported: true,
+        }));
+    }
+    return out;
+}

package/dist/extractors/swift.js

@@ -0,0 +1,192 @@
+import { namedChildren, nameOf, headerSignature, leadingComment } from "../parser.js";
+import { makeSymbol } from "./common.js";
+/* ─── helpers ─────────────────────────────────────────────────────────────── */
+function childOfType(node, type) {
+    for (let i = 0; i < node.childCount; i++) {
+        const c = node.child(i);
+        if (c && c.type === type)
+            return c;
+    }
+    return null;
+}
+function modifiersText(node) {
+    const m = childOfType(node, "modifiers");
+    return m ? m.text : "";
+}
+function vis(node) {
+    const m = modifiersText(node);
+    if (/\b(private|fileprivate)\b/.test(m))
+        return "private";
+    return "public"; // treat internal/public/open as public
+}
+function exported(node) {
+    const m = modifiersText(node);
+    return /\b(public|open)\b/.test(m) || !/\b(private|fileprivate|internal)\b/.test(m);
+}
+/** Swift uses class_declaration for `class`, `struct`, `enum`, `actor`, `extension`. */
+function classDeclKind(node) {
+    const head = node.text.slice(0, 80);
+    if (/\bstruct\b/.test(head))
+        return "struct";
+    if (/\benum\b/.test(head))
+        return "enum";
+    const body = childOfType(node, "enum_class_body");
+    if (body)
+        return "enum";
+    return "class";
+}
+/* ─── imports ─────────────────────────────────────────────────────────────── */
+export function extractImportsSwift(root, _source) {
+    const out = [];
+    for (const c of namedChildren(root)) {
+        if (c.type !== "import_declaration")
+            continue;
+        const id = childOfType(c, "identifier");
+        const text = id ? id.text : c.text.replace(/^import\s+/, "").trim();
+        out.push({ symbol: text.split(".").pop() ?? text, from: text });
+    }
+    return out;
+}
+/* ─── symbol extraction ───────────────────────────────────────────────────── */
+export function extractSwift(root, _source) {
+    return collect(namedChildren(root), false);
+}
+function collect(nodes, insideClass) {
+    const out = [];
+    for (const n of nodes) {
+        const res = handle(n, insideClass);
+        if (res)
+            out.push(res);
+    }
+    return out;
+}
+function handle(node, insideClass) {
+    switch (node.type) {
+        case "class_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const kind = classDeclKind(node);
+            const body = childOfType(node, "class_body") ?? childOfType(node, "enum_class_body");
+            return makeSymbol({
+                name,
+                kind,
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: body ? collect(namedChildren(body), true) : [],
+            });
+        }
+        case "protocol_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = childOfType(node, "protocol_body");
+            const kids = [];
+            if (body) {
+                for (const m of namedChildren(body)) {
+                    if (m.type === "protocol_function_declaration") {
+                        const n = nameOf(m);
+                        if (n) {
+                            kids.push(makeSymbol({
+                                name: n,
+                                kind: "method",
+                                node: m,
+                                rawKind: m.type,
+                                signature: headerSignature(m, null),
+                                visibility: "public",
+                                exported: true,
+                            }));
+                        }
+                    }
+                }
+            }
+            return makeSymbol({
+                name,
+                kind: "interface",
+                node,
+                rawKind: node.type,
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+                children: kids,
+            });
+        }
+        case "function_declaration": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            const body = childOfType(node, "function_body");
+            return makeSymbol({
+                name,
+                kind: insideClass ? "method" : "function",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, body),
+                visibility: vis(node),
+                exported: exported(node),
+                doc: leadingComment(node),
+            });
+        }
+        case "init_declaration": {
+            return makeSymbol({
+                name: "init",
+                kind: "method",
+                node,
+                rawKind: node.type,
+                signature: headerSignature(node, childOfType(node, "function_body")),
+                visibility: vis(node),
+                exported: exported(node),
+            });
+        }
+        case "property_declaration": {
+            // name is `pattern` field; the pattern contains simple_identifier
+            const pat = node.childForFieldName("name");
+            let name = null;
+            if (pat) {
+                const id = pat.type === "simple_identifier" ? pat : findFirstNamed(pat, "simple_identifier");
+                name = id ? id.text : null;
+            }
+            if (!name)
+                return null;
+            const isLet = /\blet\b/.test(node.text.slice(0, 30));
+            return makeSymbol({
+                name,
+                kind: insideClass ? "field" : (isLet ? "const" : "var"),
+                node,
+                rawKind: node.type,
+                signature: node.text.replace(/\s+/g, " ").trim(),
+                visibility: vis(node),
+                exported: exported(node),
+            });
+        }
+        case "enum_entry": {
+            const name = nameOf(node);
+            if (!name)
+                return null;
+            return makeSymbol({
+                name,
+                kind: "field",
+                node,
+                rawKind: node.type,
+            });
+        }
+        default:
+            return null;
+    }
+}
+function findFirstNamed(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const c = node.namedChild(i);
+        if (!c)
+            continue;
+        if (c.type === type)
+            return c;
+        const deep = findFirstNamed(c, type);
+        if (deep)
+            return deep;
+    }
+    return null;
+}