@eagleoutice/flowr 1.5.2 → 2.0.0

package/core/pipeline-executor.js

@@ -0,0 +1,221 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineExecutor = void 0;
+const assert_1 = require("../util/assert");
+/**
+ * The pipeline executor allows to execute arbitrary {@link Pipeline|pipelines} in a step-by-step fashion.
+ * If you are not yet in the possession of a {@link Pipeline|pipeline}, you can use the {@link createPipeline} function
+ * to create one for yourself, based on the steps that you want to execute.
+ *
+ * Those steps are split into two phases or "stages" (which is the name that we will use in the following), represented
+ * by the {@link PipelineStepStage} type. These allow us to separate things that have to be done
+ * once per-file, e.g., actually parsing the AST, from those that we need to repeat 'once per request' (whatever this
+ * request may be). In other words, what can be cached between operations and what cannot.
+ *
+ * Furthermore, this executor follows an iterable fashion to be *as flexible as possible*
+ * (e.g., to be instrumented with measurements). So, you can use the pipeline executor like this:
+ *
+ * ```ts
+ * const stepper = new PipelineExecutor( ... )
+ * while(stepper.hasNextStep()) {
+ *     await stepper.nextStep()
+ * }
+ *
+ * stepper.switchToRequestStage()
+ *
+ * while(stepper.hasNextStep()) {
+ *     await stepper.nextStep()
+ * }
+ *
+ * const result = stepper.getResults()
+ * ```
+ *
+ * Of course, you might think, that this is rather overkill if you simply want to receive the result.
+ * And this is true. Therefore, if you do not want to perform some kind of magic in-between steps, you can use the
+ * **{@link allRemainingSteps}** function like this:
+ *
+ * ```ts
+ * const stepper = new PipelineExecutor( ... )
+ * const result = await stepper.allRemainingSteps()
+ * ```
+ *
+ * As the name suggests, you can combine this name with previous calls to {@link nextStep} to only execute the remaining
+ * steps in case, for whatever reason you only want to instrument some steps.
+ *
+ * By default, the {@link PipelineExecutor} does not offer an automatic way to repeat requests (mostly to prevent accidental errors).
+ * However, you can use the
+ * **{@link updateRequest}** function to reset the request steps and re-execute them for a new request. This allows something like the following:
+ *
+ * ```ts
+ * const stepper = new PipelineExecutor( ... )
+ * const result = await stepper.allRemainingSteps()
+ *
+ * stepper.updateRequest( ... )
+ * const result2 = await stepper.allRemainingSteps()
+ * ```
+ *
+ * **Example - Slicing With the Pipeline Executor**:
+ *
+ * Suppose, you want to... you know _slice_ a file (which was, at one point the origin of flowR), then you can
+ * either create a pipeline yourself with the respective steps, or you can use the {@link DEFAULT_SLICING_PIPELINE} (and friends).
+ * With it, slicing essentially becomes 'easy-as-pie':
+ *
+ * ```ts
+ * const slicer = new PipelineExecutor(DEFAULT_SLICING_PIPELINE, {
+ *    shell:     new RShell(),
+ *    // of course, the criterion and request given here are just examples, you can use whatever you want to slice!
+ *    criterion: ['2@b'],
+ *    request:   requestFromInput('b <- 3; x <- 5\ncat(b)'),
+ * })
+ * const result = await slicer.allRemainingSteps()
+ * ```
+ *
+ * But now, we want to slice for `x` in the first line as well! We can do that by adding:
+ *
+ * ```ts
+ * stepper.updateRequest({ criterion: ['1@x'] })
+ * const result2 = await stepper.allRemainingSteps()
+ * ```
+ *
+ * @note Even though using the pipeline executor introduces a small performance overhead, we consider
+ * it to be the baseline for performance benchmarking. It may very well be possible to squeeze out a little bit more by
+ * directly constructing the steps in the right order. However, we consider this to be negligible when compared with the time required
+ * for, for example, the dataflow analysis of larger files.
+ *
+ * @see PipelineExecutor#allRemainingSteps
+ * @see PipelineExecutor#nextStep
+ */
+class PipelineExecutor {
+    pipeline;
+    length;
+    input;
+    output = {};
+    currentExecutionStage = 0 /* PipelineStepStage.OncePerFile */;
+    stepCounter = 0;
+    /**
+     * Construct a new pipeline executor.
+     * The required additional input is specified by the {@link IPipelineStep#requiredInput|required input configuration} of each step in the `pipeline`.
+     *
+     * @param pipeline - The {@link Pipeline} to execute, probably created with {@link createPipeline}.
+     * @param input    - External {@link PipelineInput|configuration and input} required to execute the given pipeline.
+     */
+    constructor(pipeline, input) {
+        this.pipeline = pipeline;
+        this.length = pipeline.order.length;
+        this.input = input;
+    }
+    /**
+     * Retrieve the current {@link PipelineStepStage|stage} the pipeline executor is in.
+     *
+     * @see currentExecutionStage
+     * @see switchToRequestStage
+     * @see PipelineStepStage
+     */
+    getCurrentStage() {
+        return this.currentExecutionStage;
+    }
+    /**
+     * Switch to the next {@link PipelineStepStage|stage} of the pipeline executor.
+     *
+     * This will fail if either a step change is currently not valid (as not all steps have been executed),
+     * or if there is no next stage (i.e., the pipeline is already completed or in the last stage).
+     *
+     * @see PipelineExecutor
+     * @see getCurrentStage
+     */
+    switchToRequestStage() {
+        (0, assert_1.guard)(this.stepCounter === this.pipeline.firstStepPerRequest, 'First need to complete all steps before switching');
+        (0, assert_1.guard)(this.currentExecutionStage === 0 /* PipelineStepStage.OncePerFile */, 'Cannot switch to next stage, already in per-request stage.');
+        this.currentExecutionStage = 1 /* PipelineStepStage.OncePerRequest */;
+    }
+    /**
+     * Returns the results of the pipeline.
+     *
+     * @param intermediate - Normally you can only receive the results *after* the stepper completed the step of interested.
+     * 		 However, if you pass `true` to this parameter, you can also receive the results *before* the {@link PipelineExecutor|pipeline executor}
+     * 		 completed, although the typing system then can not guarantee which of the steps have already happened.
+     */
+    getResults(intermediate = false) {
+        (0, assert_1.guard)(intermediate || this.stepCounter >= this.length, 'Without the intermediate flag, the pipeline must be completed before providing access to the results.');
+        return this.output;
+    }
+    /**
+     * Returns true only if
+     * 1) there are more {@link IPipelineStep|steps} to-do for the current {@link PipelineStepStage|stage} and
+     * 2) we have not yet reached the end of the {@link Pipeline|pipeline}.
+     */
+    hasNextStep() {
+        return (this.stepCounter < this.length && this.currentExecutionStage !== 0 /* PipelineStepStage.OncePerFile */)
+            || this.stepCounter < this.pipeline.firstStepPerRequest;
+    }
+    /**
+     * Execute the next {@link IPipelineStep|step} and return the name of the {@link IPipelineStep|step} that was executed,
+     * so you can guard if the {@link IPipelineStep|step} differs from what you are interested in.
+     * Furthermore, it returns the {@link IPipelineStep|step's} result.
+     *
+     * @param expectedStepName - A safeguard if you want to retrieve the result.
+     * 												   If given, it causes the execution to fail if the next step is not the one you expect.
+     *
+     * _Without `expectedStepName`, please refrain from accessing the result, as you have no safeguards if the pipeline changes._
+     */
+    async nextStep(expectedStepName) {
+        const [step, result] = this._doNextStep(expectedStepName);
+        const awaitedResult = await result;
+        this.output[step] = awaitedResult;
+        this.stepCounter++;
+        return { name: step, result: awaitedResult };
+    }
+    _doNextStep(expectedStepName) {
+        const step = this.pipeline.steps.get(this.pipeline.order[this.stepCounter]);
+        (0, assert_1.guard)(step !== undefined, () => `Cannot execute next step, step ${this.pipeline.order[this.stepCounter]} does not exist.`);
+        if (expectedStepName !== undefined) {
+            (0, assert_1.guard)(step.name === expectedStepName, () => `Cannot execute next step, expected step ${JSON.stringify(expectedStepName)} but got ${step.name}.`);
+        }
+        return [step.name, step.processor(this.output, this.input)];
+    }
+    /**
+     * This only makes sense if you have already run a request and want to re-use the per-file results for a new one.
+     * (or if for whatever reason, you did not pass information for the pipeline with the constructor).
+     *
+     * @param newRequestData - Data for the new request
+     */
+    updateRequest(newRequestData) {
+        const requestStep = this.pipeline.firstStepPerRequest;
+        (0, assert_1.guard)(this.stepCounter >= requestStep, 'Cannot reset request prior to once-per-request stage');
+        this.input = {
+            ...this.input,
+            ...newRequestData
+        };
+        this.stepCounter = requestStep;
+        // clear the results for all steps with an index >= firstStepPerRequest, this is more of a sanity check
+        for (let i = requestStep; i < this.length; i++) {
+            this.output[this.pipeline.order[i]] = undefined;
+        }
+    }
+    /**
+     * Execute all remaining steps and automatically call {@link switchToRequestStage} if necessary.
+     * @param canSwitchStage - If true, automatically switch to the request stage if necessary
+     *       (i.e., this is what you want if you have never executed {@link nextStep} and you want to execute *all* steps).
+     *       However, passing false allows you to only execute the steps of the 'once-per-file' stage (i.e., the steps that can be cached).
+     *
+     * @note There is a small type difference if you pass 'false' and already have manually switched to the 'once-per-request' stage.
+     *       Because now, the results of these steps are no longer part of the result type (although they are still included).
+     *       In such a case, you may be better off with simply passing 'true' as the function will detect that the stage is already switched.
+     *       We could solve this type problem by separating the {@link PipelineExecutor} class into two for each stage,
+     *       but this would break the improved readability and unified handling of the executor that I wanted to achieve with this class.
+     */
+    async allRemainingSteps(canSwitchStage = true) {
+        while (this.hasNextStep()) {
+            await this.nextStep();
+        }
+        if (canSwitchStage && this.stepCounter < this.length && this.currentExecutionStage === 0 /* PipelineStepStage.OncePerFile */) {
+            this.switchToRequestStage();
+            while (this.hasNextStep()) {
+                await this.nextStep();
+            }
+        }
+        return this.stepCounter < this.length ? this.getResults(true) : this.getResults();
+    }
+}
+exports.PipelineExecutor = PipelineExecutor;
+//# sourceMappingURL=pipeline-executor.js.map

package/core/print/dataflow-printer.d.ts

@@ -1,8 +1,7 @@
-import type { DataflowInformation } from '../../dataflow/internal/info';
+import type { DataflowInformation } from '../../dataflow/info';
 import type { QuadSerializationConfiguration } from '../../util/quads';
-import type { DataflowMap } from '../../dataflow';
 /** Should work with larger things as well */
 export declare function dataflowGraphToJson(df: DataflowInformation): string;
-export declare function dataflowGraphToMermaid(df: DataflowInformation, idMap: DataflowMap): string;
-export declare function dataflowGraphToMermaidUrl(df: DataflowInformation, idMap: DataflowMap): string;
+export declare function dataflowGraphToMermaid(df: DataflowInformation): string;
+export declare function dataflowGraphToMermaidUrl(df: DataflowInformation): string;
 export declare function dataflowGraphToQuads(df: DataflowInformation, config: QuadSerializationConfiguration): string;

package/core/print/dataflow-printer.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.dataflowGraphToQuads = exports.dataflowGraphToMermaidUrl = exports.dataflowGraphToMermaid = exports.dataflowGraphToJson = void 0;
 const json_1 = require("../../util/json");
 const quads_1 = require("../../dataflow/graph/quads");
-const mermaid_1 = require("../../util/mermaid");
+const dfg_1 = require("../../util/mermaid/dfg");
 function mayObjectJson(d) {
     if (typeof d === 'object') {
         return objectJson(d);
@@ -47,12 +47,12 @@ function dataflowGraphToJson(df) {
     return objectJson(df);
 }
 exports.dataflowGraphToJson = dataflowGraphToJson;
-function dataflowGraphToMermaid(df, idMap) {
-    return (0, mermaid_1.graphToMermaid)(df.graph, idMap);
+function dataflowGraphToMermaid(df) {
+    return (0, dfg_1.graphToMermaid)({ graph: df.graph }).string;
 }
 exports.dataflowGraphToMermaid = dataflowGraphToMermaid;
-function dataflowGraphToMermaidUrl(df, idMap) {
-    return (0, mermaid_1.graphToMermaidUrl)(df.graph, idMap);
+function dataflowGraphToMermaidUrl(df) {
+    return (0, dfg_1.graphToMermaidUrl)(df.graph);
 }
 exports.dataflowGraphToMermaidUrl = dataflowGraphToMermaidUrl;
 function dataflowGraphToQuads(df, config) {

package/core/print/normalize-printer.d.ts

@@ -1,5 +1,5 @@
-import type { NormalizedAst } from '../../r-bridge';
 import type { QuadSerializationConfiguration } from '../../util/quads';
+import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 /** Should work with larger things as well */
 export declare function normalizedAstToJson(ast: NormalizedAst): string;
 export declare function normalizedAstToQuads(ast: NormalizedAst, config: QuadSerializationConfiguration): string;

package/core/print/normalize-printer.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.printNormalizedAstToMermaidUrl = exports.printNormalizedAstToMermaid = exports.normalizedAstToQuads = exports.normalizedAstToJson = void 0;
 const json_1 = require("../../util/json");
 const quads_1 = require("../../util/quads");
-const mermaid_1 = require("../../util/mermaid");
+const ast_1 = require("../../util/mermaid/ast");
 /** Should work with larger things as well */
 function normalizedAstToJson(ast) {
     // we never serialize the idmap, as it just duplicates the ast, additionally we now miss the full-lexeme to further safe memory
@@ -21,11 +21,11 @@ function normalizedAstToQuads(ast, config) {
 }
 exports.normalizedAstToQuads = normalizedAstToQuads;
 function printNormalizedAstToMermaid(ast) {
-    return (0, mermaid_1.normalizedAstToMermaid)(ast.ast);
+    return (0, ast_1.normalizedAstToMermaid)(ast.ast);
 }
 exports.printNormalizedAstToMermaid = printNormalizedAstToMermaid;
 function printNormalizedAstToMermaidUrl(ast) {
-    return (0, mermaid_1.normalizedAstToMermaidUrl)(ast.ast);
+    return (0, ast_1.normalizedAstToMermaidUrl)(ast.ast);
 }
 exports.printNormalizedAstToMermaidUrl = printNormalizedAstToMermaidUrl;
 //# sourceMappingURL=normalize-printer.js.map

package/core/print/parse-printer.js

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseToQuads = void 0;
 const quads_1 = require("../../util/quads");
-const r_bridge_1 = require("../../r-bridge");
-const format_1 = require("../../r-bridge/lang-4.x/ast/parser/json/format");
 const parser_1 = require("../../r-bridge/lang-4.x/ast/parser/json/parser");
+const format_1 = require("../../r-bridge/lang-4.x/ast/parser/json/format");
+const input_format_1 = require("../../r-bridge/lang-4.x/ast/parser/xml/input-format");
 function filterObject(obj, keys) {
     if (typeof obj !== 'object') {
         return obj;
@@ -25,7 +25,7 @@ function filterObject(obj, keys) {
 function parseToQuads(code, config) {
     const obj = (0, parser_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(code));
     // recursively filter so that if the object contains one of the keys 'a', 'b' or 'c', all other keys are ignored
-    return (0, quads_1.serialize2quads)(filterObject(obj, new Set([r_bridge_1.attributesKey, r_bridge_1.childrenKey, r_bridge_1.contentKey])), config);
+    return (0, quads_1.serialize2quads)(filterObject(obj, new Set([input_format_1.attributesKey, input_format_1.childrenKey, input_format_1.contentKey])), config);
 }
 exports.parseToQuads = parseToQuads;
 //# sourceMappingURL=parse-printer.js.map

package/core/print/print.d.ts

@@ -1,4 +1,5 @@
-import type { StepFunction } from '../steps';
+import type { IPipelineStep, StepProcessingFunction } from '../steps/pipeline-step';
+import type { TailOfArray } from '../../util/arrays';
 /**
  * Defines the output format of a step that you are interested in.
  */
@@ -37,11 +38,19 @@ export declare const enum StepOutputFormat {
 /**
  * Helper function to support the {@link Internal} format, as it is simply returning the input.
  *
- * @see IStepPrinter
+ * @see IPipelineStepPrinter
  */
 export declare function internalPrinter<Input>(input: Input): Input;
 /**
  * A mapping function that maps the result of a step (i.e., the dataflow graph)
- * to another representation (linked by {@link StepOutputFormat} in an {@link IStep}).
+ * to another representation (linked by {@link StepOutputFormat} in an {@link IPipelineStep}).
+ *
+ * For the internal format, refer to {@link InternalStepPrinter} as a shorthand.
+ */
+export type IPipelineStepPrinter<StepInput extends StepProcessingFunction, Format extends StepOutputFormat, AdditionalInput extends unknown[]> = Format extends StepOutputFormat.Internal ? (input: Awaited<ReturnType<StepInput>>) => Awaited<ReturnType<StepInput>> : (input: Awaited<ReturnType<StepInput>>, ...additional: AdditionalInput) => Promise<string> | string;
+export type InternalStepPrinter<StepInput extends StepProcessingFunction> = IPipelineStepPrinter<StepInput, StepOutputFormat.Internal, []>;
+/**
+ * For a `step` of the given name, which returned the given `data`. Convert that data into the given `format`.
+ * Depending on your step and the format this may require `additional` inputs.
  */
-export type IStepPrinter<StepInput extends StepFunction, Format extends StepOutputFormat, AdditionalInput extends unknown[]> = Format extends StepOutputFormat.Internal ? (input: Awaited<ReturnType<StepInput>>) => Awaited<ReturnType<StepInput>> : (input: Awaited<ReturnType<StepInput>>, ...additional: AdditionalInput) => Promise<string> | string;
+export declare function printStepResult<Step extends IPipelineStep, Processor extends Step['processor'], Format extends Exclude<keyof Step['printer'], StepOutputFormat.Internal> & number, Printer extends Step['printer'][Format], AdditionalInput extends TailOfArray<Parameters<Printer>>>(step: Step, data: Awaited<ReturnType<Processor>>, format: Format, ...additional: AdditionalInput): Promise<string>;

package/core/print/print.js

@@ -1,13 +1,24 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.internalPrinter = void 0;
+exports.printStepResult = exports.internalPrinter = void 0;
+const assert_1 = require("../../util/assert");
 /**
  * Helper function to support the {@link Internal} format, as it is simply returning the input.
  *
- * @see IStepPrinter
+ * @see IPipelineStepPrinter
  */
 function internalPrinter(input) {
     return input;
 }
 exports.internalPrinter = internalPrinter;
+/**
+ * For a `step` of the given name, which returned the given `data`. Convert that data into the given `format`.
+ * Depending on your step and the format this may require `additional` inputs.
+ */
+function printStepResult(step, data, format, ...additional) {
+    const printer = step.printer[format];
+    (0, assert_1.guard)(printer !== undefined, `printer for ${step.name} does not support ${String(format)}`);
+    return printer(data, ...additional);
+}
+exports.printStepResult = printStepResult;
 //# sourceMappingURL=print.js.map

package/core/print/slice-diff-ansi.d.ts

@@ -1,2 +1,3 @@
-import type { NodeId, NormalizedAst } from '../../r-bridge';
-export declare function sliceDiffAnsi(slice: Set<NodeId>, normalized: NormalizedAst, criteriaIds: Set<NodeId>, originalCode: string): string;
+import type { NodeId } from '../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { NormalizedAst } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export declare function sliceDiffAnsi(slice: ReadonlySet<NodeId>, normalized: NormalizedAst, criteriaIds: ReadonlySet<NodeId>, originalCode: string): string;

package/core/print/slice-diff-ansi.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.sliceDiffAnsi = void 0;
 const range_1 = require("../../util/range");
 const assert_1 = require("../../util/assert");
-const ansi_1 = require("../../../src/util/ansi");
+const ansi_1 = require("../../util/ansi");
 function grayOut() {
     return ansi_1.ansiFormatter.getFormatString({ color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 2 /* FontStyles.Faint */ });
 }
@@ -39,9 +39,9 @@ function sliceDiffAnsi(slice, normalized, criteriaIds, originalCode) {
     importantLocations = mergeJointRangesInSorted(importantLocations);
     const lines = originalCode.split('\n');
     for (const { selected, location } of importantLocations) {
-        const { start, end } = location;
-        const line = lines[start.line - 1];
-        lines[start.line - 1] = `${line.substring(0, start.column - 1)}${ansi_1.ansiFormatter.reset()}${highlight(line.substring(start.column - 1, end.column), selected)}${grayOut()}${line.substring(end.column)}`;
+        const [sl, sc, , ec] = location;
+        const line = lines[sl - 1];
+        lines[sl - 1] = `${line.substring(0, sc - 1)}${ansi_1.ansiFormatter.reset()}${highlight(line.substring(sc - 1, ec), selected)}${grayOut()}${line.substring(ec)}`;
     }
     return `${grayOut()}${lines.join('\n')}${ansi_1.ansiFormatter.reset()}`;
 }

package/core/steps/all/core/00-parse.d.ts

@@ -0,0 +1,28 @@
+import { internalPrinter } from '../../../print/print';
+import { parseToQuads } from '../../../print/parse-printer';
+import { PipelineStepStage } from '../../pipeline-step';
+import type { RShellExecutor } from '../../../../r-bridge/shell-executor';
+import type { RShell } from '../../../../r-bridge/shell';
+import type { RParseRequest } from '../../../../r-bridge/retriever';
+export interface ParseRequiredInput {
+    /** This is the {@link RShell} or {@link RShellExecutor} connection to be used to obtain the original parses AST of the R code */
+    readonly shell: RShell | RShellExecutor;
+    /** The request which essentially indicates the input to extract the AST from */
+    readonly request: RParseRequest;
+}
+declare function processor(_results: unknown, input: Partial<ParseRequiredInput>): import("ts-essentials").AsyncOrSync<string>;
+export declare const PARSE_WITH_R_SHELL_STEP: {
+    readonly name: "parse";
+    readonly humanReadableName: "parse with R shell";
+    readonly description: "Parse the given R code into an AST";
+    readonly processor: typeof processor;
+    readonly executed: PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof internalPrinter;
+        readonly 2: (text: string) => string;
+        readonly 5: typeof parseToQuads;
+    };
+    readonly dependencies: readonly [];
+    readonly requiredInput: ParseRequiredInput;
+};
+export {};

package/core/steps/all/core/00-parse.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PARSE_WITH_R_SHELL_STEP = void 0;
+const print_1 = require("../../../print/print");
+const parse_printer_1 = require("../../../print/parse-printer");
+const retriever_1 = require("../../../../r-bridge/retriever");
+function processor(_results, input) {
+    return (0, retriever_1.retrieveParseDataFromRCode)(input.request, input.shell);
+}
+exports.PARSE_WITH_R_SHELL_STEP = {
+    name: 'parse',
+    humanReadableName: 'parse with R shell',
+    description: 'Parse the given R code into an AST',
+    processor,
+    executed: 0 /* PipelineStepStage.OncePerFile */,
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
+        [2 /* StepOutputFormat.Json */]: text => text,
+        [5 /* StepOutputFormat.RdfQuads */]: parse_printer_1.parseToQuads
+    },
+    dependencies: [],
+    requiredInput: undefined
+};
+//# sourceMappingURL=00-parse.js.map

package/core/steps/all/core/10-normalize.d.ts

@@ -0,0 +1,29 @@
+import { internalPrinter } from '../../../print/print';
+import { normalizedAstToJson, normalizedAstToQuads, printNormalizedAstToMermaid, printNormalizedAstToMermaidUrl } from '../../../print/normalize-printer';
+import { PipelineStepStage } from '../../pipeline-step';
+import type { IdGenerator } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { NoInfo } from '../../../../r-bridge/lang-4.x/ast/model/model';
+export interface NormalizeRequiredInput {
+    /** This id generator is only necessary if you want to retrieve a dataflow from the parsed R AST, it determines the id generator to use and by default uses the {@link deterministicCountingIdGenerator}*/
+    readonly getId?: IdGenerator<NoInfo>;
+}
+declare function processor(results: {
+    parse?: string;
+}, input: Partial<NormalizeRequiredInput>): import("../../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+export declare const NORMALIZE: {
+    readonly name: "normalize";
+    readonly humanReadableName: "normalize";
+    readonly description: "Normalize the AST to flowR's AST";
+    readonly processor: typeof processor;
+    readonly executed: PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof internalPrinter;
+        readonly 2: typeof normalizedAstToJson;
+        readonly 5: typeof normalizedAstToQuads;
+        readonly 3: typeof printNormalizedAstToMermaid;
+        readonly 4: typeof printNormalizedAstToMermaidUrl;
+    };
+    readonly dependencies: readonly ["parse"];
+    readonly requiredInput: NormalizeRequiredInput;
+};
+export {};

package/core/steps/all/core/10-normalize.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NORMALIZE = void 0;
+const print_1 = require("../../../print/print");
+const normalize_printer_1 = require("../../../print/normalize-printer");
+const parser_1 = require("../../../../r-bridge/lang-4.x/ast/parser/json/parser");
+function processor(results, input) {
+    return (0, parser_1.normalize)(results.parse, input.getId);
+}
+exports.NORMALIZE = {
+    name: 'normalize',
+    humanReadableName: 'normalize',
+    description: 'Normalize the AST to flowR\'s AST',
+    processor,
+    executed: 0 /* PipelineStepStage.OncePerFile */,
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
+        [2 /* StepOutputFormat.Json */]: normalize_printer_1.normalizedAstToJson,
+        [5 /* StepOutputFormat.RdfQuads */]: normalize_printer_1.normalizedAstToQuads,
+        [3 /* StepOutputFormat.Mermaid */]: normalize_printer_1.printNormalizedAstToMermaid,
+        [4 /* StepOutputFormat.MermaidUrl */]: normalize_printer_1.printNormalizedAstToMermaidUrl
+    },
+    dependencies: ['parse'],
+    requiredInput: undefined
+};
+//# sourceMappingURL=10-normalize.js.map

package/core/steps/all/core/20-dataflow.d.ts

@@ -0,0 +1,27 @@
+import { internalPrinter } from '../../../print/print';
+import { PipelineStepStage } from '../../pipeline-step';
+import { dataflowGraphToJson, dataflowGraphToMermaid, dataflowGraphToMermaidUrl, dataflowGraphToQuads } from '../../../print/dataflow-printer';
+import type { NormalizedAst } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { RParseRequest } from '../../../../r-bridge/retriever';
+declare function legacyProcessor(results: {
+    normalize?: NormalizedAst;
+}, input: {
+    request?: RParseRequest;
+}): import("../../../../dataflow/info").DataflowInformation;
+export declare const STATIC_DATAFLOW: {
+    readonly humanReadableName: "dataflow";
+    readonly processor: typeof legacyProcessor;
+    readonly requiredInput: {};
+    readonly name: "dataflow";
+    readonly description: "Construct the dataflow graph";
+    readonly executed: PipelineStepStage.OncePerFile;
+    readonly printer: {
+        readonly 0: typeof internalPrinter;
+        readonly 2: typeof dataflowGraphToJson;
+        readonly 5: typeof dataflowGraphToQuads;
+        readonly 3: typeof dataflowGraphToMermaid;
+        readonly 4: typeof dataflowGraphToMermaidUrl;
+    };
+    readonly dependencies: readonly ["normalize"];
+};
+export {};

package/core/steps/all/core/20-dataflow.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATIC_DATAFLOW = void 0;
+const print_1 = require("../../../print/print");
+const dataflow_printer_1 = require("../../../print/dataflow-printer");
+const extractor_1 = require("../../../../dataflow/extractor");
+const staticDataflowCommon = {
+    name: 'dataflow',
+    description: 'Construct the dataflow graph',
+    executed: 0 /* PipelineStepStage.OncePerFile */,
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter,
+        [2 /* StepOutputFormat.Json */]: dataflow_printer_1.dataflowGraphToJson,
+        [5 /* StepOutputFormat.RdfQuads */]: dataflow_printer_1.dataflowGraphToQuads,
+        [3 /* StepOutputFormat.Mermaid */]: dataflow_printer_1.dataflowGraphToMermaid,
+        [4 /* StepOutputFormat.MermaidUrl */]: dataflow_printer_1.dataflowGraphToMermaidUrl
+    },
+    dependencies: ['normalize'],
+};
+function legacyProcessor(results, input) {
+    return (0, extractor_1.produceDataFlowGraph)(input.request, results.normalize);
+}
+exports.STATIC_DATAFLOW = {
+    ...staticDataflowCommon,
+    humanReadableName: 'dataflow',
+    processor: legacyProcessor,
+    requiredInput: {}
+};
+//# sourceMappingURL=20-dataflow.js.map

package/core/steps/all/static-slicing/00-slice.d.ts

@@ -0,0 +1,28 @@
+import { internalPrinter } from '../../../print/print';
+import { PipelineStepStage } from '../../pipeline-step';
+import type { DataflowInformation } from '../../../../dataflow/info';
+import type { SlicingCriteria } from '../../../../slicing/criterion/parse';
+import type { NormalizedAst } from '../../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+export interface SliceRequiredInput {
+    /** The slicing criterion is only of interest if you actually want to slice the R code */
+    readonly criterion: SlicingCriteria;
+    /** How many re-visits of the same node are ok? */
+    readonly threshold?: number;
+}
+declare function processor(results: {
+    dataflow?: DataflowInformation;
+    normalize?: NormalizedAst;
+}, input: Partial<SliceRequiredInput>): Readonly<import("../../../../slicing/static/slicer-types").SliceResult>;
+export declare const STATIC_SLICE: {
+    readonly name: "slice";
+    readonly humanReadableName: "static slice";
+    readonly description: "Calculate the actual static slice from the dataflow graph and the given slicing criteria";
+    readonly processor: typeof processor;
+    readonly executed: PipelineStepStage.OncePerRequest;
+    readonly printer: {
+        readonly 0: typeof internalPrinter;
+    };
+    readonly dependencies: readonly ["dataflow"];
+    readonly requiredInput: SliceRequiredInput;
+};
+export {};

package/core/steps/all/static-slicing/00-slice.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATIC_SLICE = void 0;
+const print_1 = require("../../../print/print");
+const static_slicer_1 = require("../../../../slicing/static/static-slicer");
+function processor(results, input) {
+    return (0, static_slicer_1.staticSlicing)(results.dataflow.graph, results.normalize, input.criterion, input.threshold);
+}
+exports.STATIC_SLICE = {
+    name: 'slice',
+    humanReadableName: 'static slice',
+    description: 'Calculate the actual static slice from the dataflow graph and the given slicing criteria',
+    processor,
+    executed: 1 /* PipelineStepStage.OncePerRequest */,
+    printer: {
+        [0 /* StepOutputFormat.Internal */]: print_1.internalPrinter
+    },
+    dependencies: ['dataflow'],
+    requiredInput: undefined
+};
+//# sourceMappingURL=00-slice.js.map