@eagleoutice/flowr 1.3.11

package/cli/repl/commands/parse.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCommand = void 0;
+const r_bridge_1 = require("../../../r-bridge");
+const internal_1 = require("../../../r-bridge/lang-4.x/ast/parser/xml/internal");
+const core_1 = require("../../../core");
+const objects_1 = require("../../../util/objects");
+function toDepthMap(xml, config) {
+    const root = (0, r_bridge_1.getKeysGuarded)(xml, "exprlist" /* RawRType.ExpressionList */);
+    const visit = [{ depth: 0, node: root }];
+    const result = [];
+    while (visit.length > 0) {
+        const current = visit.pop();
+        if (current === undefined) {
+            continue;
+        }
+        const children = current.node[config.childrenName] ?? [];
+        result.push({ ...current, leaf: children.length === 0 });
+        children.reverse();
+        const nextDepth = current.depth + 1;
+        visit.push(...children.map(c => ({ depth: nextDepth, node: c })));
+    }
+    return result;
+}
+function lastElementInNesting(i, list, depth) {
+    for (let j = i + 1; j < list.length; j++) {
+        if (list[j].depth < depth) {
+            return true;
+        }
+        if (list[j].depth === depth) {
+            return false;
+        }
+    }
+    // only more deeply nested come after
+    return true;
+}
+function initialIndentation(i, depth, deadDepths, nextDepth, list, f) {
+    let result = `${i === 0 ? '' : '\n'}${f.getFormatString({ style: 2 /* FontStyles.Faint */ })}`;
+    // we know there never is something on the same level as the expression list
+    for (let d = 1; d < depth; d++) {
+        result += deadDepths.has(d) ? '  ' : '│ ';
+    }
+    if (nextDepth < depth) {
+        result += '╰ ';
+    }
+    else if (i > 0) {
+        // check if we are maybe the last one with this depth until someone with a lower depth comes around
+        const isLast = lastElementInNesting(i, list, depth);
+        result += isLast ? '╰ ' : '├ ';
+        if (isLast) {
+            deadDepths.add(depth);
+        }
+    }
+    return result;
+}
+function retrieveLocationString(locationRaw) {
+    const extracted = (0, internal_1.extractLocation)(locationRaw);
+    if (extracted.start.line === extracted.end.line && extracted.start.column === extracted.end.column) {
+        return ` (${extracted.start.line}:${extracted.start.column})`;
+    }
+    else {
+        return ` (${extracted.start.line}:${extracted.start.column}─${extracted.end.line}:${extracted.end.column})`;
+    }
+}
+function depthListToTextTree(list, config, f) {
+    let result = '';
+    const deadDepths = new Set();
+    let i = 0;
+    for (const { depth, node, leaf } of list) {
+        const nextDepth = i + 1 < list.length ? list[i + 1].depth : 0;
+        deadDepths.delete(depth);
+        result += initialIndentation(i, depth, deadDepths, nextDepth, list, f);
+        result += f.reset();
+        const raw = (0, internal_1.objectWithArrUnwrap)(node);
+        const content = raw[config.contentName];
+        const locationRaw = raw[config.attributeName];
+        let location = '';
+        if (locationRaw !== undefined) {
+            location = retrieveLocationString(locationRaw);
+        }
+        const type = (0, internal_1.getTokenType)(config.tokenMap, node);
+        if (leaf) {
+            const suffix = `${f.format(content ? JSON.stringify(content) : '', { style: 1 /* FontStyles.Bold */ })}${f.format(location, { style: 3 /* FontStyles.Italic */ })}`;
+            result += `${type} ${suffix}`;
+        }
+        else {
+            result += f.format(type, { style: 1 /* FontStyles.Bold */ });
+        }
+        i++;
+    }
+    return result;
+}
+exports.parseCommand = {
+    description: 'Prints ASCII Art of the parsed, unmodified AST, start with \'file://\' to indicate a file',
+    usageExample: ':parse',
+    aliases: ['p'],
+    script: false,
+    fn: async (output, shell, remainingLine) => {
+        const result = await new core_1.SteppingSlicer({
+            stepOfInterest: 'parse',
+            shell,
+            request: (0, r_bridge_1.requestFromInput)(remainingLine.trim())
+        }).allRemainingSteps();
+        const config = (0, objects_1.deepMergeObject)(r_bridge_1.DEFAULT_XML_PARSER_CONFIG, { tokenMap: await shell.tokenMap() });
+        const object = await (0, internal_1.xlm2jsonObject)(config, result.parse);
+        output.stdout(depthListToTextTree(toDepthMap(object, config), config, output.formatter));
+    }
+};
+//# sourceMappingURL=parse.js.map

package/cli/repl/commands/quit.d.ts

@@ -0,0 +1,2 @@
+import { ReplCommand } from './main';
+export declare const quitCommand: ReplCommand;

package/cli/repl/commands/quit.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quitCommand = void 0;
+const log_1 = require("../../../util/log");
+exports.quitCommand = {
+    description: 'End the repl',
+    aliases: ['q', 'exit'],
+    usageExample: ':quit',
+    script: false,
+    fn: () => { log_1.log.info('bye'); process.exit(0); }
+};
+//# sourceMappingURL=quit.js.map

package/cli/repl/commands/version.d.ts

@@ -0,0 +1,16 @@
+import { ReplCommand, ReplOutput } from './main';
+import { RShell } from '../../../r-bridge';
+type Version = `${number}.${number}.${number}`;
+/**
+ * Describes the version of flowR and the used R interpreter.
+ */
+export interface VersionInformation {
+    /** The version of flowR */
+    flowr: Version;
+    /** The version of R identified by the underlying {@link RShell} */
+    r: Version | 'unknown';
+}
+export declare function retrieveVersionInformation(shell?: RShell): Promise<VersionInformation>;
+export declare function printVersionInformation(output: ReplOutput, shell?: RShell): Promise<void>;
+export declare const versionCommand: ReplCommand;
+export {};

package/cli/repl/commands/version.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionCommand = exports.printVersionInformation = exports.retrieveVersionInformation = void 0;
+const r_bridge_1 = require("../../../r-bridge");
+const package_json_1 = require("../../../../package.json");
+const assert_1 = require("../../../util/assert");
+const versionRegex = /^\d+\.\d+\.\d+/m;
+async function retrieveVersionInformation(shell) {
+    if (shell === undefined) {
+        shell = new r_bridge_1.RShell();
+        process.on('exit', () => shell.close());
+    }
+    const flowr = package_json_1.version;
+    const r = (await shell.usedRVersion())?.format() ?? 'unknown';
+    (0, assert_1.guard)(versionRegex.test(flowr), `flowR version ${flowr} does not match the expected format!`);
+    (0, assert_1.guard)(r === 'unknown' || versionRegex.test(r), `R version ${r} does not match the expected format!`);
+    return { flowr: flowr, r: r };
+}
+exports.retrieveVersionInformation = retrieveVersionInformation;
+async function printVersionInformation(output, shell) {
+    const { flowr, r } = await retrieveVersionInformation(shell);
+    output.stdout(`flowR: ${flowr}`);
+    output.stdout(`R: ${r}`);
+}
+exports.printVersionInformation = printVersionInformation;
+exports.versionCommand = {
+    description: 'Prints the version of flowR as well as the current version of R',
+    aliases: [],
+    usageExample: ':version',
+    script: false,
+    fn: (output, shell) => printVersionInformation(output, shell)
+};
+//# sourceMappingURL=version.js.map

package/cli/repl/core.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/**
+ * Basically a helper file to allow the main 'flowr' script (located in the source root) to provide its repl
+ *
+ * @module
+ */
+import { RShell } from '../../r-bridge';
+import readline from 'readline/promises';
+import { ReplOutput } from './commands';
+import { ReadLineOptions } from 'node:readline';
+/**
+ * Used by the repl to provide automatic completions for a given (partial) input line
+ */
+export declare function replCompleter(line: string): [string[], string];
+export declare const DEFAULT_REPL_READLINE_CONFIGURATION: ReadLineOptions;
+/**
+ * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
+ *
+ * @param output   - Defines two methods that every function in the repl uses to output its data.
+ * @param expr     - The expression to process.
+ * @param shell    - The {@link RShell} to use (see {@link repl}).
+ */
+export declare function replProcessAnswer(output: ReplOutput, expr: string, shell: RShell): Promise<void>;
+/**
+ * Provides a never-ending repl (read-evaluate-print loop) processor that can be used to interact with a {@link RShell} as well as all flowR scripts.
+ *
+ * The repl allows for two kinds of inputs:
+ * - Starting with a colon `:`, indicating a command (probe `:help`, and refer to {@link commands}) </li>
+ * - Starting with anything else, indicating default R code to be directly executed. If you kill the underlying shell, that is on you! </li>
+ *
+ * @param shell     - The shell to use, if you do not pass one it will automatically create a new one with the `revive` option set to 'always'
+ * @param rl        - A potentially customized readline interface to be used for the repl to *read* from the user, we write the output with the {@link ReplOutput | `output` } interface.
+ *                    If you want to provide a custom one but use the same `completer`, refer to {@link replCompleter}.
+ *                    For the default arguments, see {@link DEFAULT_REPL_READLINE_CONFIGURATION}.
+ * @param output    - Defines two methods that every function in the repl uses to output its data.
+ *
+ * For the execution, this function makes use of {@link replProcessAnswer}
+ *
+ */
+export declare function repl(shell?: RShell, rl?: readline.Interface, output?: ReplOutput): Promise<void>;

package/cli/repl/core.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repl = exports.replProcessAnswer = exports.DEFAULT_REPL_READLINE_CONFIGURATION = exports.replCompleter = void 0;
+/**
+ * Basically a helper file to allow the main 'flowr' script (located in the source root) to provide its repl
+ *
+ * @module
+ */
+const r_bridge_1 = require("../../r-bridge");
+const promises_1 = __importDefault(require("readline/promises"));
+const statistics_1 = require("../../statistics");
+const prompt_1 = require("./prompt");
+const commands_1 = require("./commands");
+const args_1 = require("../../util/args");
+const execute_1 = require("./commands/execute");
+const replCompleterKeywords = Array.from(commands_1.commandNames, s => `:${s}`);
+/**
+ * Used by the repl to provide automatic completions for a given (partial) input line
+ */
+function replCompleter(line) {
+    return [replCompleterKeywords.filter(k => k.startsWith(line)), line];
+}
+exports.replCompleter = replCompleter;
+exports.DEFAULT_REPL_READLINE_CONFIGURATION = {
+    input: process.stdin,
+    output: process.stdout,
+    tabSize: 4,
+    terminal: true,
+    removeHistoryDuplicates: true,
+    completer: replCompleter
+};
+async function replProcessStatement(output, statement, shell) {
+    if (statement.startsWith(':')) {
+        const command = statement.slice(1).split(' ')[0].toLowerCase();
+        const processor = (0, commands_1.getCommand)(command);
+        if (processor) {
+            await processor.fn(output, shell, statement.slice(command.length + 2).trim());
+        }
+        else {
+            console.log(`the command '${command}' is unknown, try ${(0, statistics_1.bold)(':help')} for more information`);
+        }
+    }
+    else {
+        await (0, execute_1.executeRShellCommand)(output, shell, statement);
+    }
+}
+/**
+ * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
+ *
+ * @param output   - Defines two methods that every function in the repl uses to output its data.
+ * @param expr     - The expression to process.
+ * @param shell    - The {@link RShell} to use (see {@link repl}).
+ */
+async function replProcessAnswer(output, expr, shell) {
+    const statements = (0, args_1.splitAtEscapeSensitive)(expr, ';');
+    for (const statement of statements) {
+        await replProcessStatement(output, statement, shell);
+    }
+}
+exports.replProcessAnswer = replProcessAnswer;
+/**
+ * Provides a never-ending repl (read-evaluate-print loop) processor that can be used to interact with a {@link RShell} as well as all flowR scripts.
+ *
+ * The repl allows for two kinds of inputs:
+ * - Starting with a colon `:`, indicating a command (probe `:help`, and refer to {@link commands}) </li>
+ * - Starting with anything else, indicating default R code to be directly executed. If you kill the underlying shell, that is on you! </li>
+ *
+ * @param shell     - The shell to use, if you do not pass one it will automatically create a new one with the `revive` option set to 'always'
+ * @param rl        - A potentially customized readline interface to be used for the repl to *read* from the user, we write the output with the {@link ReplOutput | `output` } interface.
+ *                    If you want to provide a custom one but use the same `completer`, refer to {@link replCompleter}.
+ *                    For the default arguments, see {@link DEFAULT_REPL_READLINE_CONFIGURATION}.
+ * @param output    - Defines two methods that every function in the repl uses to output its data.
+ *
+ * For the execution, this function makes use of {@link replProcessAnswer}
+ *
+ */
+async function repl(shell = new r_bridge_1.RShell({ revive: 'always' }), rl = promises_1.default.createInterface(exports.DEFAULT_REPL_READLINE_CONFIGURATION), output = commands_1.standardReplOutput) {
+    // the incredible repl :D, we kill it with ':quit'
+    // eslint-disable-next-line no-constant-condition,@typescript-eslint/no-unnecessary-condition
+    while (true) {
+        const answer = await rl.question((0, prompt_1.prompt)());
+        await replProcessAnswer(output, answer, shell);
+    }
+}
+exports.repl = repl;
+//# sourceMappingURL=core.js.map

package/cli/repl/execute.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { Readable, Writable } from 'node:stream';
+type Stdio = [stdin: Writable | null, stdout: Readable | null, stderr: Readable | null, extra: Writable | Readable | null | undefined, extra: Writable | Readable | null | undefined];
+export type StdioProcessor = (stdio: Stdio) => void;
+/**
+ * Simply captures the output of the script executed by {@link waitOnScript}.
+ *
+ * @param stdio        - The standard io tuple provided by {@link waitOnScript}
+ * @param onStdOutLine - The callback is executed each time we receive a new line from the standard output channel.
+ * @param onStdErrLine - The callback is executed each time we receive a new line from the standard error channel.
+ */
+export declare function stdioCaptureProcessor(stdio: Stdio, onStdOutLine: (msg: string) => void, onStdErrLine: (msg: string) => void): void;
+/**
+ * Run the given module with the presented arguments, and wait for it to exit.
+ *
+ * @param module      - The (flowR) module that you want to use for the fork.
+ *                      It is probably best to use {@link __dirname} so you can specify the module relative to your
+ *                      current one.
+ * @param args        - The arguments you want to start your process with.
+ * @param io          - If you omit this argument, the in-, out- and error-channels of the script execution
+ *                      will be automatically forwarded to the respective in-, out- and error-channels of your process.
+ *                      However, by defining `io` you essentially gain full control on what should happen
+ *                      with these streams. For a simple capturing processor, for example if you want to collect
+ *                      the output of the script, see {@link stdioCaptureProcessor}.
+ * @param exitOnError - If set to `true`, the process will exit with the exit code of the script.
+ */
+export declare function waitOnScript(module: string, args: string[], io?: StdioProcessor, exitOnError?: boolean): Promise<void>;
+export {};

package/cli/repl/execute.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitOnScript = exports.stdioCaptureProcessor = void 0;
+const log_1 = require("../../util/log");
+const child_process_1 = __importDefault(require("child_process"));
+const node_readline_1 = __importDefault(require("node:readline"));
+const assert_1 = require("../../util/assert");
+/**
+ * Simply captures the output of the script executed by {@link waitOnScript}.
+ *
+ * @param stdio        - The standard io tuple provided by {@link waitOnScript}
+ * @param onStdOutLine - The callback is executed each time we receive a new line from the standard output channel.
+ * @param onStdErrLine - The callback is executed each time we receive a new line from the standard error channel.
+ */
+function stdioCaptureProcessor(stdio, onStdOutLine, onStdErrLine) {
+    (0, assert_1.guard)(stdio[1] !== null, 'no stdout given in stdio!');
+    const outRl = node_readline_1.default.createInterface({
+        input: stdio[1],
+        terminal: false
+    });
+    (0, assert_1.guard)(stdio[2] !== null, 'no stderr given in stdio!');
+    const errRl = node_readline_1.default.createInterface({
+        input: stdio[2],
+        terminal: false
+    });
+    outRl.on('line', onStdOutLine);
+    errRl.on('line', onStdErrLine);
+}
+exports.stdioCaptureProcessor = stdioCaptureProcessor;
+/**
+ * Run the given module with the presented arguments, and wait for it to exit.
+ *
+ * @param module      - The (flowR) module that you want to use for the fork.
+ *                      It is probably best to use {@link __dirname} so you can specify the module relative to your
+ *                      current one.
+ * @param args        - The arguments you want to start your process with.
+ * @param io          - If you omit this argument, the in-, out- and error-channels of the script execution
+ *                      will be automatically forwarded to the respective in-, out- and error-channels of your process.
+ *                      However, by defining `io` you essentially gain full control on what should happen
+ *                      with these streams. For a simple capturing processor, for example if you want to collect
+ *                      the output of the script, see {@link stdioCaptureProcessor}.
+ * @param exitOnError - If set to `true`, the process will exit with the exit code of the script.
+ */
+async function waitOnScript(module, args, io, exitOnError = false) {
+    log_1.log.info(`starting script ${module} with args ${JSON.stringify(args)}`);
+    const child = child_process_1.default.fork(module, args, {
+        silent: io !== undefined
+    });
+    if (io !== undefined) {
+        io(child.stdio);
+    }
+    child.on('exit', (code, signal) => {
+        if (code) {
+            console.error(`Script ${module} exited with code ${String(code)} and signal ${JSON.stringify(signal)}`);
+            if (exitOnError) {
+                process.exit(code);
+            }
+        }
+    });
+    child.on('error', err => {
+        console.error(`Script ${module} signaled error ${JSON.stringify(err)}`);
+        if (exitOnError) {
+            process.exit(1);
+        }
+    });
+    await new Promise((resolve, reject) => child.on('exit', code => {
+        if (exitOnError && code) {
+            reject(new Error(`Script ${module} exited with code ${String(code)}`));
+        }
+        else {
+            resolve();
+        }
+    }));
+}
+exports.waitOnScript = waitOnScript;
+//# sourceMappingURL=execute.js.map

package/cli/repl/index.d.ts

@@ -0,0 +1,5 @@
+export * from './server/messages/messages';
+export * from './core';
+export * from './prompt';
+export * from './server/messages/messages';
+export * from './execute';

package/cli/repl/index.js

@@ -0,0 +1,22 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./server/messages/messages"), exports);
+__exportStar(require("./core"), exports);
+__exportStar(require("./prompt"), exports);
+__exportStar(require("./server/messages/messages"), exports);
+__exportStar(require("./execute"), exports);
+//# sourceMappingURL=index.js.map

package/cli/repl/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const rawPrompt = "R>";
+export declare const prompt: () => string;

package/cli/repl/prompt.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = exports.rawPrompt = void 0;
+const statistics_1 = require("../../statistics");
+exports.rawPrompt = 'R>';
+// is a function as the 'formatter' is configured only after the cli options have been read
+const prompt = () => `${statistics_1.formatter.format(exports.rawPrompt, { color: 6 /* Colors.Cyan */, effect: statistics_1.ColorEffect.Foreground })} `;
+exports.prompt = prompt;
+//# sourceMappingURL=prompt.js.map

package/cli/repl/server/connection.d.ts

@@ -0,0 +1,21 @@
+import { RShell } from '../../../r-bridge';
+import { Socket } from './net';
+/**
+ * Each connection handles a single client, answering to its requests.
+ * There is no need to construct this class manually, {@link FlowRServer} will do it for you.
+ */
+export declare class FlowRServerConnection {
+    private readonly socket;
+    private readonly shell;
+    private readonly name;
+    private readonly logger;
+    private readonly fileMap;
+    constructor(socket: Socket, name: string, shell: RShell);
+    private currentMessageBuffer;
+    private handleData;
+    private handleFileAnalysisRequest;
+    private sendFileAnalysisResponse;
+    private createSteppingSlicerForRequest;
+    private handleSliceRequest;
+    private handleRepl;
+}