@eagleoutice/flowr-dev/queries/catalog/project-query/project-query-executor.js

Static Dataflow Analyzer and Program Slicer for the R Programming Language

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.executeProjectQuery = executeProjectQuery;
const log_1 = require("../../../util/log");
const flowr_file_1 = require("../../../project/context/flowr-file");
const r_base_packages_1 = require("../../../util/r-base-packages");
/**
 * Collects dependency statistics from what the project declares, cross-referenced with the
 * loaded signature database(s) to report how many dependencies we can cover.
 */
function collectDependencyStats(declared, deps, basePackages) {
    const imports = declared.imports ?? [];
    const dependsAll = declared.depends ?? [];
    const rEntry = dependsAll.find(d => d.name === 'R');
    const rVersion = rEntry?.derivedRange?.raw;
    const depends = dependsAll.filter(d => d.name !== 'R');
    const suggests = declared.suggests ?? [];
    const linkingTo = declared.linkingTo ?? [];
    const runtime = new Set([...imports, ...depends, ...linkingTo].map(p => p.name));
    let base = 0;
    let covered = 0;
    const first = [];
    for (const name of runtime) {
        const isBase = basePackages.has(name);
        const resolved = isBase ? undefined : deps.getDependency(name);
        if (isBase) {
            base++;
        }
        else if (resolved?.namespaceInfo) {
            covered++;
        }
        if (first.length < 3) {
            first.push({ name, base: isBase, dbVersion: resolved?.resolvedVersion });
        }
    }
    return {
        imports: imports.length,
        depends: depends.length,
        suggests: suggests.length,
        linkingTo: linkingTo.length,
        runtime: runtime.size,
        base,
        covered,
        first,
        rVersion: rVersion && /\d/.test(rVersion) ? rVersion : undefined
    };
}
/**
 * Executes the given project queries.
 */
async function executeProjectQuery({ analyzer }, queries) {
    if (queries.length !== 1) {
        log_1.log.warn('Project query expects only up to one query, but got', queries.length);
    }
    const startTime = Date.now();
    const withDf = queries.some(q => q.withDf);
    // we need to know what is considered by the analyzer
    if (withDf) {
        await analyzer.dataflow();
    }
    const ctx = analyzer.inspectContext();
    const basePackages = new Set(ctx.config.project.basePackages ?? (0, r_base_packages_1.baseRPackages)(ctx.resolvedRVersion));
    const roleCounts = {};
    for (const file of Object.values(flowr_file_1.FileRole)) {
        roleCounts[file] = ctx.files.getFilesByRole(file).length;
    }
    // whichever plugin read the metadata (DESCRIPTION, rproject.toml, a lockfile) contributed it to the context,
    // so nothing here has to know which file the project happens to use
    const declared = ctx.meta.getDeclaredPackages();
    const hasDeclarations = Object.values(declared).some(g => g !== undefined);
    return {
        '.meta': {
            timing: Date.now() - startTime
        },
        name: ctx.meta.getProjectName() ?? ctx.meta.getProjectTitle(),
        files: Array.from(ctx.files.consideredFilesList()),
        authors: ctx.meta.getAuthors(),
        encoding: ctx.meta.getEncoding(),
        version: ctx.meta.getProjectVersion()?.str,
        rVersion: ctx.meta.getRVersion(),
        licenses: ctx.meta.getLicenses(),
        roleCounts: roleCounts,
        kind: ctx.projectKind(),
        dependencies: hasDeclarations ? collectDependencyStats(declared, ctx.deps, basePackages) : undefined
    };
}
//# sourceMappingURL=project-query-executor.js.map