@plebeiantech/lat.md 0.12.3-fork.15 → 0.12.3-fork.17

package/dist/src/source-parser.js

@@ -28,12 +28,16 @@ async function ensureParser() {
 const grammarMap = {
     '.c': 'tree-sitter-c.wasm',
     '.dart': 'tree-sitter-dart.wasm',
+    '.erb': 'tree-sitter-ruby.wasm',
     '.go': 'tree-sitter-go.wasm',
     '.h': 'tree-sitter-c.wasm',
     '.java': 'tree-sitter-java.wasm',
     '.js': 'tree-sitter-javascript.wasm',
     '.jsx': 'tree-sitter-javascript.wasm',
+    '.php': 'tree-sitter-php.wasm',
     '.py': 'tree-sitter-python.wasm',
+    '.rake': 'tree-sitter-ruby.wasm',
+    '.rb': 'tree-sitter-ruby.wasm',
     '.rs': 'tree-sitter-rust.wasm',
     '.ts': 'tree-sitter-typescript.wasm',
     '.tsx': 'tree-sitter-tsx.wasm',
@@ -246,6 +250,202 @@ function extractPySymbols(tree) {
     }
     return symbols;
 }
+function collectRubyScope(scope, parent, symbols) {
+    for (const node of scope.namedChildren) {
+        const startLine = node.startPosition.row + 1;
+        const endLine = node.endPosition.row + 1;
+        const signature = firstLine(node.text);
+        if (node.type === 'class' || node.type === 'module') {
+            const nameNode = node.childForFieldName('name');
+            if (nameNode) {
+                let childPart;
+                let parentPart;
+                if (nameNode.type === 'scope_resolution' &&
+                    nameNode.namedChildren.length === 2) {
+                    parentPart = nameNode.namedChildren[0].text;
+                    childPart = nameNode.namedChildren[1].text;
+                    symbols.push({
+                        name: childPart,
+                        kind: 'class',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    symbols.push({
+                        name: childPart,
+                        kind: 'class',
+                        parent: parentPart,
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                }
+                else {
+                    childPart = nameNode.text;
+                    symbols.push({
+                        name: childPart,
+                        kind: 'class',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    if (parent) {
+                        symbols.push({
+                            name: childPart,
+                            kind: 'class',
+                            parent,
+                            startLine,
+                            endLine,
+                            signature,
+                        });
+                    }
+                }
+                const body = node.childForFieldName('body');
+                if (body) {
+                    collectRubyScope(body, childPart, symbols);
+                }
+            }
+        }
+        else if (node.type === 'method' || node.type === 'singleton_method') {
+            const name = extractName(node);
+            if (name) {
+                symbols.push({
+                    name,
+                    kind: parent ? 'method' : 'function',
+                    ...(parent ? { parent } : {}),
+                    startLine,
+                    endLine,
+                    signature,
+                });
+            }
+        }
+        else if (node.type === 'assignment') {
+            const left = node.childForFieldName('left');
+            if (left) {
+                if (left.type === 'scope_resolution' &&
+                    left.namedChildren.length === 2) {
+                    const parentPart = left.namedChildren[0].text;
+                    const childPart = left.namedChildren[1].text;
+                    symbols.push({
+                        name: childPart,
+                        kind: 'const',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    symbols.push({
+                        name: childPart,
+                        kind: 'const',
+                        parent: parentPart,
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                }
+                else if (left.type === 'constant' ||
+                    (left.type === 'identifier' && /^[A-Z]/.test(left.text))) {
+                    const name = left.text;
+                    symbols.push({
+                        name,
+                        kind: 'const',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    if (parent) {
+                        symbols.push({
+                            name,
+                            kind: 'const',
+                            parent,
+                            startLine,
+                            endLine,
+                            signature,
+                        });
+                    }
+                }
+            }
+        }
+        else if (node.type === 'call') {
+            const methodNode = node.childForFieldName('method');
+            const methodName = methodNode?.text;
+            if (methodName === 'task' ||
+                methodName === 'multitask' ||
+                methodName === 'file') {
+                const name = extractRubyRakeName(node);
+                if (name) {
+                    symbols.push({
+                        name,
+                        kind: parent ? 'method' : 'function',
+                        ...(parent ? { parent } : {}),
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                }
+            }
+            else if (methodName === 'namespace') {
+                const name = extractRubyRakeName(node);
+                if (name) {
+                    symbols.push({
+                        name,
+                        kind: 'class',
+                        startLine,
+                        endLine,
+                        signature,
+                    });
+                    if (parent) {
+                        symbols.push({
+                            name,
+                            kind: 'class',
+                            parent,
+                            startLine,
+                            endLine,
+                            signature,
+                        });
+                    }
+                    const block = node.childForFieldName('block') ??
+                        node.namedChildren.find((n) => n.type === 'do_block' || n.type === 'block');
+                    if (block) {
+                        const body = block.childForFieldName('body') ??
+                            block.namedChildren.find((n) => n.type === 'body_statement' || n.type === 'block_body') ??
+                            block;
+                        collectRubyScope(body, name, symbols);
+                    }
+                }
+            }
+        }
+    }
+}
+function extractRubyRakeName(node) {
+    const args = node.childForFieldName('arguments');
+    if (!args || args.namedChildren.length === 0)
+        return null;
+    let first = args.namedChildren[0];
+    if (first.type === 'pair') {
+        first = first.childForFieldName('key') ?? first.namedChildren[0];
+    }
+    if (!first)
+        return null;
+    if (first.type === 'simple_symbol') {
+        return first.text.replace(/^:/, '');
+    }
+    if (first.type === 'hash_key_symbol') {
+        return first.text.replace(/:$/, '');
+    }
+    if (first.type === 'string') {
+        const content = first.namedChildren.find((c) => c.type === 'string_content');
+        return content ? content.text : first.text.replace(/^['"]|['"]$/g, '');
+    }
+    if (first.type === 'identifier') {
+        return first.text;
+    }
+    return null;
+}
+function extractRubySymbols(tree) {
+    const symbols = [];
+    collectRubyScope(tree.rootNode, undefined, symbols);
+    return symbols;
+}
 function dartDirectChild(node, type) {
     return node.namedChildren.find((child) => child.type === type) ?? null;
 }
@@ -554,6 +754,125 @@ function extractJavaSymbols(tree) {
     collectJavaScope(sourceLines, tree.rootNode, undefined, symbols);
     return symbols;
 }
+function phpSignature(sourceLines, node) {
+    const declaration = node.namedChildren.find((child) => child.type !== 'attribute_list');
+    return sourceLines[(declaration ?? node).startPosition.row]?.trim() ?? '';
+}
+function phpName(node) {
+    const nameNode = node.childForFieldName('name');
+    if (nameNode?.type === 'by_ref') {
+        return (nameNode.namedChildren
+            .find((child) => child.type === 'variable_name')
+            ?.text.replace(/^\$/, '') ?? null);
+    }
+    const name = extractName(node) ??
+        node.namedChildren.find((child) => child.type === 'name')?.text ??
+        null;
+    return name?.replace(/^\$/, '') ?? null;
+}
+function pushPhpSymbol(sourceLines, symbols, node, name, kind, parent) {
+    symbols.push({
+        name,
+        kind,
+        ...(parent ? { parent } : {}),
+        startLine: node.startPosition.row + 1,
+        endLine: node.endPosition.row + 1,
+        signature: phpSignature(sourceLines, node),
+    });
+}
+function extractPhpVariables(sourceLines, symbols, node, parent) {
+    const kind = node.type === 'const_declaration' ? 'const' : 'variable';
+    for (const child of node.namedChildren) {
+        if (child.type !== 'const_element' && child.type !== 'property_element') {
+            continue;
+        }
+        const name = phpName(child);
+        if (name)
+            pushPhpSymbol(sourceLines, symbols, node, name, kind, parent);
+    }
+}
+const phpTypeKinds = {
+    class_declaration: 'class',
+    interface_declaration: 'interface',
+    trait_declaration: 'interface',
+    enum_declaration: 'class',
+};
+// Recurse through declaration containers, not arbitrary expressions: anonymous
+// classes and closures must not leak their members into the enclosing scope.
+const phpScopeContainers = new Set([
+    'namespace_definition',
+    'compound_statement',
+    'declaration_list',
+    'enum_declaration_list',
+    'if_statement',
+    'else_if_clause',
+    'else_clause',
+    'switch_statement',
+    'switch_block',
+    'case_statement',
+    'default_statement',
+    'while_statement',
+    'do_statement',
+    'for_statement',
+    'foreach_statement',
+    'try_statement',
+    'catch_clause',
+    'finally_clause',
+    'declare_statement',
+]);
+function collectPhpScope(sourceLines, scope, symbols, parent) {
+    for (const node of scope.namedChildren) {
+        const typeKind = phpTypeKinds[node.type];
+        if (typeKind) {
+            const name = phpName(node);
+            if (!name)
+                continue;
+            pushPhpSymbol(sourceLines, symbols, node, name, typeKind);
+            const body = node.childForFieldName('body');
+            if (body)
+                collectPhpScope(sourceLines, body, symbols, name);
+            continue;
+        }
+        if (node.type === 'function_definition' && !parent) {
+            const name = phpName(node);
+            if (name)
+                pushPhpSymbol(sourceLines, symbols, node, name, 'function');
+        }
+        else if (node.type === 'method_declaration' && parent) {
+            const name = phpName(node);
+            if (name)
+                pushPhpSymbol(sourceLines, symbols, node, name, 'method', parent);
+            if (name?.toLowerCase() === '__construct') {
+                const parameters = node.childForFieldName('parameters');
+                for (const parameter of parameters?.namedChildren ?? []) {
+                    if (parameter.type !== 'property_promotion_parameter')
+                        continue;
+                    const propertyName = phpName(parameter);
+                    if (!propertyName)
+                        continue;
+                    pushPhpSymbol(sourceLines, symbols, parameter, propertyName, 'variable', parent);
+                }
+            }
+        }
+        else if (node.type === 'const_declaration' ||
+            node.type === 'property_declaration') {
+            extractPhpVariables(sourceLines, symbols, node, parent);
+        }
+        else if (node.type === 'enum_case' && parent) {
+            const name = phpName(node);
+            if (name)
+                pushPhpSymbol(sourceLines, symbols, node, name, 'const', parent);
+        }
+        else if (phpScopeContainers.has(node.type)) {
+            collectPhpScope(sourceLines, node, symbols, parent);
+        }
+    }
+}
+function extractPhpSymbols(tree) {
+    const symbols = [];
+    collectPhpScope(tree.rootNode.text.split('\n'), tree.rootNode, symbols);
+    return symbols;
+}
 function extractRustSymbols(tree) {
     const symbols = [];
     const root = tree.rootNode;
@@ -1096,16 +1415,92 @@ function firstLine(text) {
 const symbolExtractors = {
     '.c': extractCSymbols,
     '.dart': extractDartSymbols,
+    '.erb': extractRubySymbols,
     '.go': extractGoSymbols,
     '.h': extractCSymbols,
     '.java': extractJavaSymbols,
     '.js': extractTsSymbols,
     '.jsx': extractTsSymbols,
+    '.php': extractPhpSymbols,
     '.py': extractPySymbols,
+    '.rake': extractRubySymbols,
+    '.rb': extractRubySymbols,
     '.rs': extractRustSymbols,
     '.ts': extractTsSymbols,
     '.tsx': extractTsSymbols,
 };
+function preprocessErb(content) {
+    let result = '';
+    let inRuby = false;
+    let inComment = false;
+    let i = 0;
+    while (i < content.length) {
+        if (!inRuby && !inComment) {
+            if (content.startsWith('<%%', i)) {
+                result += '   ';
+                i += 3;
+            }
+            else if (content.startsWith('<%#', i)) {
+                inComment = true;
+                result += '   ';
+                i += 3;
+            }
+            else if (content.startsWith('<%', i)) {
+                inRuby = true;
+                let tagLen = 2;
+                while (i + tagLen < content.length &&
+                    ['=', '-', '~'].includes(content[i + tagLen])) {
+                    tagLen++;
+                }
+                result += ' '.repeat(tagLen);
+                i += tagLen;
+            }
+            else {
+                const ch = content[i];
+                result += ch === '\n' ? '\n' : ' ';
+                i++;
+            }
+        }
+        else if (inComment) {
+            if (content.startsWith('%>', i)) {
+                inComment = false;
+                result += '  ';
+                i += 2;
+            }
+            else if (content.startsWith('-%>', i) || content.startsWith('~%>', i)) {
+                inComment = false;
+                result += '   ';
+                i += 3;
+            }
+            else {
+                const ch = content[i];
+                result += ch === '\n' ? '\n' : ' ';
+                i++;
+            }
+        }
+        else {
+            if (content.startsWith('%%>', i)) {
+                result += '   ';
+                i += 3;
+            }
+            else if (content.startsWith('%>', i)) {
+                inRuby = false;
+                result += '  ';
+                i += 2;
+            }
+            else if (content.startsWith('-%>', i) || content.startsWith('~%>', i)) {
+                inRuby = false;
+                result += '   ';
+                i += 3;
+            }
+            else {
+                result += content[i];
+                i++;
+            }
+        }
+    }
+    return result;
+}
 export async function parseSourceSymbols(filePath, content) {
     const ext = sourceFileExtension(filePath);
     if (!ext)
@@ -1113,7 +1508,8 @@ export async function parseSourceSymbols(filePath, content) {
     const lang = await getLanguage(ext);
     const p = await ensureParser();
     p.setLanguage(lang);
-    const tree = p.parse(content);
+    const parsedContent = ext === '.erb' && content.includes('<%') ? preprocessErb(content) : content;
+    const tree = p.parse(parsedContent);
     if (!tree)
         return [];
     try {