@eagleoutice/flowr-dev/queries/catalog/signature-query/signature-query-format.js

Static Dataflow Analyzer and Program Slicer for the R Programming Language

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.SignatureQueryDefinition = void 0;
const joi_1 = __importDefault(require("joi"));
const ansi_1 = require("../../../util/text/ansi");
const time_1 = require("../../../util/text/time");
const signature_query_executor_1 = require("./signature-query-executor");
const signature_query_render_1 = require("./signature-query-render");
/** parse a signature-query repl line into a query: `pkg`, `pkg fn`, `pkg::fn`, `pkg@ver`, globs */
function signatureQueryLineParser(output, line, _config) {
    // pull the `--param <name>` (repeatable, comma-separable) / `--required <n>` flags out, leaving the positional tokens
    const parameters = [];
    let requiredParameters;
    let callGraph = false;
    const positional = [];
    for (let i = 0; i < line.length; i++) {
        const tok = line[i];
        if (tok.length === 0) {
            continue;
        }
        if (tok === '--param' || tok === '-p') {
            parameters.push(...(line[++i] ?? '').split(',').map(s => s.trim()).filter(s => s.length > 0));
        }
        else if (tok === '--required' || tok === '--req') {
            requiredParameters = Number(line[++i]);
        }
        else if (tok === '--cg') {
            callGraph = true;
        }
        else if (!tok.startsWith('--')) {
            positional.push(tok);
        }
    }
    // help only when it is the leading word or an explicit flag, never for a package/function literally named `help`
    if (positional[0] === 'help' || line.includes('--help') || line.includes('-h')) {
        (0, signature_query_render_1.printSignatureHelp)(output);
        return { query: [] };
    }
    const paramFilters = {
        ...(parameters.length > 0 ? { parameters } : {}),
        ...(requiredParameters !== undefined && !Number.isNaN(requiredParameters) ? { requiredParameters } : {}),
        ...(callGraph ? { callGraph: true } : {})
    };
    const hasParamFilter = parameters.length > 0 || (requiredParameters !== undefined && !Number.isNaN(requiredParameters));
    const [first, second] = positional;
    if (!first) {
        // a bare parameter filter (`--param fuzz`) searches every package; otherwise summarize the databases
        return { query: [{ type: 'signature', ...(hasParamFilter ? { package: '*' } : {}), ...paramFilters }] };
    }
    // `pkg::fn` shorthand, then `pkg@version`
    const dbl = first.indexOf('::');
    const left = dbl >= 0 ? first.slice(0, dbl) : first;
    const fnFromColon = dbl >= 0 ? first.slice(dbl + 2) : undefined;
    const at = left.indexOf('@');
    const pkg = at >= 0 ? left.slice(0, at) : left;
    const version = at >= 0 ? left.slice(at + 1) : undefined;
    const fn = second ?? fnFromColon;
    return {
        query: [{
                type: 'signature',
                ...(pkg ? { package: pkg } : {}),
                ...(fn ? { function: fn } : {}),
                ...(version ? { version } : {}),
                ...paramFilters
            }]
    };
}
exports.SignatureQueryDefinition = {
    title: 'Signature Query',
    executor: signature_query_executor_1.executeSignatureQuery,
    asciiSummarizer: (formatter, _analyzer, queryResults, result, _query) => {
        const out = queryResults;
        result.push(`Query: ${(0, ansi_1.bold)('signature', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
        if (out.function) {
            (0, signature_query_render_1.pushFunction)(result, formatter, out.function);
        }
        else if (out.package) {
            (0, signature_query_render_1.pushPackage)(result, formatter, out.package);
        }
        else if (out.matches) {
            (0, signature_query_render_1.pushMatches)(result, formatter, out);
        }
        else if (out.packages) {
            (0, signature_query_render_1.pushPackages)(result, formatter, out);
        }
        else if (!out.message) {
            (0, signature_query_render_1.pushSummary)(result, formatter, out);
        }
        if (out.message) {
            const hint = out.suggestions?.length ? ` ${(0, ansi_1.italic)('Did you mean:', formatter)} ${out.suggestions.join(', ')}?` : '';
            result.push(`   ╰ ${(0, ansi_1.color)(out.message, 1 /* Colors.Red */, formatter)}${hint}`);
        }
        return true;
    },
    fromLine: signatureQueryLineParser,
    completer: signature_query_executor_1.signatureQueryCompleter,
    syntax: '@signature [<pkg>[@<version>]] [<pkg>::<fn> | <fn>] [--param <name>[,...]] [--required <n>] [--cg] [--help]',
    schema: joi_1.default.object({
        type: joi_1.default.string().valid('signature').required().description('The type of the query.'),
        package: joi_1.default.string().optional().description('The package to inspect (glob wildcards allowed); omit for a summary of the loaded databases.'),
        function: joi_1.default.string().optional().description('A function/symbol to inspect (glob wildcards allowed).'),
        version: joi_1.default.string().optional().description('A version spec: an exact version, a glob (3.*), a semver range (>=3.0.0, 3.x), or a release-date bound (<=2026, >=2021.05 in YYYY.MM.DD).'),
        parameters: joi_1.default.array().items(joi_1.default.string()).optional().description('Keep only functions that have a parameter matching every one of these names (glob wildcards allowed, position-independent).'),
        requiredParameters: joi_1.default.number().integer().min(0).optional().description('Keep only functions with exactly this many required (no-default) parameters, excluding `...`.'),
        callGraph: joi_1.default.boolean().optional().description('For a single function, also render its transitive call graph as a mermaid.live link (`--cg`).')
    }).description('Inspects the loaded signature database(s): loaded databases, a package, a function, or wildcard matches (optionally filtered by parameter name or required-parameter count).'),
    flattenInvolvedNodes: () => []
};
//# sourceMappingURL=signature-query-format.js.map