universal-ast-mapper 1.27.0 → 2.0.0

package/dist/extractors/ruby.js

@@ -1,146 +0,0 @@
-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

@@ -1,249 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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;
-}