@eagleoutice/flowr-dev/cli/flowr.js

Static Dataflow Analyzer and Program Slicer for the R Programming Language

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.optionHelp = exports.toolName = void 0;
const version_1 = require("../util/version");
const command_line_usage_1 = __importDefault(require("command-line-usage"));
const log_1 = require("../util/log");
const ansi_1 = require("../util/text/ansi");
const command_line_args_1 = __importDefault(require("command-line-args"));
const config_1 = require("../config");
const assert_1 = require("../util/assert");
const scripts_info_1 = require("./common/scripts-info");
const execute_1 = require("./repl/execute");
const repl_main_1 = require("./repl/commands/repl-main");
const core_1 = require("./repl/core");
const proc_1 = require("../util/proc");
const print_version_1 = require("./repl/print-version");
const flowr_main_options_1 = require("./flowr-main-options");
const fs_1 = __importDefault(require("fs"));
const path_1 = __importDefault(require("path"));
const engines_1 = require("../engines");
const flowr_analyzer_builder_1 = require("../project/flowr-analyzer-builder");
exports.toolName = 'flowr';
exports.optionHelp = [
    {
        header: `flowR (version ${(0, version_1.flowrVersion)().toString()})`,
        content: 'A static dataflow analyzer and program slicer for R programs'
    },
    {
        header: 'Synopsis',
        content: [
            `$ ${exports.toolName} {bold --help}`,
            `$ ${exports.toolName} {bold --version}`,
            `$ ${exports.toolName} {bold --server}`,
            `$ ${exports.toolName} {bold --execute} {italic ":parse 2 - 4"}`,
            `$ ${exports.toolName} {bold slicer} {bold --help}`,
        ]
    },
    {
        header: 'Options',
        optionList: flowr_main_options_1.flowrMainOptionDefinitions
    }
];
const options = (0, command_line_args_1.default)(flowr_main_options_1.flowrMainOptionDefinitions);
log_1.log.updateSettings(l => l.settings.minLevel = options.verbose ? 1 /* LogLevel.Trace */ : 5 /* LogLevel.Error */);
log_1.log.info('running with options', options);
if (options['no-ansi'] || (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '')) {
    log_1.log.info('disabling ansi colors');
    (0, ansi_1.setFormatter)(ansi_1.voidFormatter);
}
function createConfig() {
    let config;
    if (options['config-json']) {
        const passedConfig = config_1.FlowrConfig.parse(options['config-json']);
        if (passedConfig) {
            log_1.log.info(`Using passed config ${JSON.stringify(passedConfig)}`);
            config = passedConfig;
        }
    }
    if (config == undefined) {
        if (options['no-fs']) {
            config = config_1.FlowrConfig.default();
        }
        else {
            if (options['config-file']) {
                // validate it exists
                if (!fs_1.default.existsSync(path_1.default.resolve(options['config-file']))) {
                    log_1.log.error(`Config file '${options['config-file']}' does not exist`);
                    process.exit(1);
                }
            }
            config = config_1.FlowrConfig.fromFile(options['config-file'] ?? flowr_main_options_1.defaultConfigFile);
        }
    }
    // for all options that we manually supply that have a config equivalent, set them in the config
    config = config_1.FlowrConfig.amend(config, c => {
        c.engines ??= [];
        if (!options['engine.r-shell.disabled']) {
            c.engines.push({ type: 'r-shell', rPath: options['r-path'] || options['engine.r-shell.r-path'] });
        }
        if (!options['engine.tree-sitter.disabled']) {
            c.engines.push({
                type: 'tree-sitter',
                wasmPath: options['engine.tree-sitter.wasm-path'],
                treeSitterWasmPath: options['engine.tree-sitter.tree-sitter-wasm-path'],
                lax: options['engine.tree-sitter.lax']
            });
        }
        if (options['default-engine']) {
            c.defaultEngine = options['default-engine'];
        }
        if (options['no-fs']) {
            c.solver.sigdb.enabled = false;
        }
        return c;
    });
    return config;
}
function hookSignalHandlers(engines) {
    const end = () => {
        if (options.execute === undefined) {
            console.log(`\n${(0, ansi_1.italic)('Exiting...')}`);
        }
        Object.values(engines.engines).forEach(e => e?.close());
        (0, proc_1.exitSafe)(0);
    };
    process.on('SIGINT', end);
    process.on('SIGTERM', end);
}
function getReplPlugins(config) {
    const plugins = config.repl.plugins.filter(p => p !== 'flowr:default');
    if (plugins.length !== config.repl.plugins.length) {
        return plugins.concat(config.defaultPlugins);
    }
    else {
        return plugins;
    }
}
async function mainRepl() {
    const config = createConfig();
    if (options.script) {
        const script = scripts_info_1.scripts[options.script];
        (0, assert_1.guard)(script !== undefined, `Unknown script target "${options.script}", pick one of ${(0, flowr_main_options_1.getScriptsText)()}.`);
        const target = script.target;
        (0, assert_1.guard)(target !== undefined, `Unknown script target "${options.script}", pick one of ${(0, flowr_main_options_1.getScriptsText)()}.`);
        console.log(`Running script '${ansi_1.formatter.format(options.script, { style: 1 /* FontStyles.Bold */ })}'`);
        log_1.log.debug(`Script maps to "${target}"`);
        await (0, execute_1.waitOnScript)(`${__dirname}/${target}`, (0, flowr_main_options_1.getScriptArguments)(options.script, process.argv), undefined, true);
        return (0, proc_1.exitSafe)(0);
    }
    if (options.help) {
        console.log((0, command_line_usage_1.default)(exports.optionHelp));
        return (0, proc_1.exitSafe)(0);
    }
    const engines = await (0, engines_1.retrieveEngineInstances)(config);
    const defaultEngine = engines.engines[engines.default];
    if (options.version) {
        const enginesList = Object.values(engines.engines);
        if (enginesList.length > 0) {
            await (0, version_1.printVersionInformation)(repl_main_1.standardReplOutput, enginesList[0]);
            for (const engine of enginesList.slice(1)) {
                console.log('');
                await (0, version_1.printVersionInformation)(repl_main_1.standardReplOutput, engine, true);
            }
        }
        for (const engine of enginesList) {
            engine?.close();
        }
        return (0, proc_1.exitSafe)(0);
    }
    hookSignalHandlers(engines);
    const analyzer = new flowr_analyzer_builder_1.FlowrAnalyzerBuilder(false)
        .setParser(defaultEngine)
        .setConfig(config)
        .registerPlugins(...getReplPlugins(config))
        .buildSync();
    const allowRSessionAccess = options['r-session-access'] ?? false;
    if (options.execute) {
        await (0, core_1.replProcessAnswer)(analyzer, repl_main_1.standardReplOutput, options.execute, allowRSessionAccess);
    }
    else {
        await (0, print_version_1.printVersionRepl)(defaultEngine);
        const w = (x) => ansi_1.ansiFormatter.format(x, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
        console.log(w('use ') + ansi_1.ansiFormatter.format(':help', { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ }) + w(' to get a list of available commands.'));
        await (0, core_1.repl)({ analyzer, allowRSessionAccess, ...(options['no-fs'] ? { historyFile: '' } : {}) });
    }
    (0, proc_1.exitSafe)(0);
}
async function mainServer(useWebSocket) {
    const config = createConfig();
    const engines = await (0, engines_1.retrieveEngineInstances)(config);
    hookSignalHandlers(engines);
    // the server stack (incl. the `ws` websocket library) is only loaded when actually running a server,
    // so the common one-shot analysis path does not pay for evaluating it
    const { FlowRServer } = await Promise.resolve().then(() => __importStar(require('./repl/server/server')));
    const { NetServer, WebSocketServerWrapper } = await Promise.resolve().then(() => __importStar(require('./repl/server/net')));
    const backend = useWebSocket ? new WebSocketServerWrapper() : new NetServer();
    await new FlowRServer(engines.engines, engines.default, options['r-session-access'], config, backend).start(options.port);
}
async function main() {
    try {
        if (options.server) {
            await mainServer(options.ws);
        }
        else {
            await mainRepl();
        }
    }
    catch (e) {
        const err = e;
        console.error(ansi_1.formatter.format(`flowR failed to start: ${err.message}`, { color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ }));
        if (options.verbose) {
            console.error(err.stack);
        }
        else {
            console.error((0, ansi_1.italic)('Run again with --verbose for the full stack trace.'));
        }
        (0, proc_1.exitSafe)(1);
    }
}
void main();
//# sourceMappingURL=flowr.js.map