@eagleoutice/flowr 2.7.4 → 2.7.6

package/util/r-license.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRLicense = parseRLicense;
+const semver_1 = require("semver");
+const assert_1 = require("./assert");
+const objects_1 = require("./objects");
+/**
+ * Parses an R license string into its structured representation.
+ */
+function parseRLicense(licenseString) {
+    const start = skipWhitespace({ position: 0, remInput: licenseString });
+    const parsed = parseLicenseInfo(start);
+    return parsed.element;
+}
+function parseLicenseInfo(info) {
+    info = skipWhitespace(info);
+    if (info.remInput.length === 0) {
+        return { ...info, element: { type: 'no-license' } };
+    }
+    else if (info.remInput.startsWith('(')) {
+        return parseParenthesizedExpression(info);
+    }
+    else {
+        return parseBinaryOperator(info);
+    }
+}
+function parseParenthesizedExpression(info) {
+    const openParen = consumeString(info, '(');
+    (0, assert_1.guard)(openParen.element, `Expected (, but found ${info.remInput[0]} at position ${info.position}`);
+    const innerInfo = parseLicenseInfo(openParen);
+    const closeParen = consumeString(innerInfo, ')');
+    (0, assert_1.guard)(closeParen.element, `Expected ), but found ${innerInfo.remInput[0]} at position ${innerInfo.position}`);
+    return { ...closeParen, element: innerInfo.element };
+}
+function skipWhitespace({ remInput, position }) {
+    let idx = remInput.search(/\S/);
+    if (idx === -1) {
+        idx = remInput.length;
+    }
+    position += idx;
+    remInput = remInput.slice(idx);
+    return { position, remInput };
+}
+function consumeLicenseName(info) {
+    info = skipWhitespace(info);
+    let licenseName = '';
+    let isAtWhitespace = false;
+    for (let i = 0; i < info.remInput.length; i++) {
+        const char = info.remInput[i];
+        if (/[()<>~!=,&|+]/.test(char)) {
+            break;
+        }
+        else {
+            isAtWhitespace = /\s/.test(char);
+        }
+        if (isAtWhitespace) {
+            if (/^\s*(with|and|or)\s+/i.test(info.remInput.slice(i))) {
+                break;
+            }
+        }
+        licenseName += char;
+    }
+    const newInfo = {
+        position: info.position + licenseName.length,
+        remInput: info.remInput.slice(licenseName.length)
+    };
+    // file licenses are a special case!
+    if (licenseName && /^file[\s-]+license$/i.test(licenseName.trim())) {
+        return { ...newInfo, element: 'file LICENSE' };
+    }
+    return { ...newInfo, element: licenseName?.trim() ?? '' };
+}
+function makeRange(rangeStr) {
+    try {
+        rangeStr = rangeStr.trim().replaceAll('==', '=');
+        return new semver_1.Range(rangeStr);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseLicenseElement(info) {
+    const licenseName = consumeLicenseName(info);
+    info = skipWhitespace(licenseName);
+    // may be followed by version constraint in parentheses or directly
+    let versionConstraint;
+    if (/^\(\s*?[\d<>=!~]/.test(info.remInput)) {
+        // version constraint
+        if (info.remInput.startsWith('(')) {
+            const openParen = consumeString(info, '(');
+            (0, assert_1.guard)(openParen.element, `Expected (, but found ${info.remInput[0]} at position ${info.position}`);
+            info = skipWhitespace(openParen);
+            // consume until closing parenthesis
+            const versionStr = consumeUntilString(info, ')');
+            versionConstraint = makeRange(versionStr.element);
+            const closeParen = consumeString(versionStr, ')');
+            (0, assert_1.guard)(closeParen.element, `Expected ), but found ${versionStr.remInput[0]} at position ${versionStr.position}`);
+            info = skipWhitespace(closeParen);
+        }
+        else {
+            // consume until whitespace or special character
+            const versionStr = consumeRegexp(info, /^[\d<>=!~.\s]+/);
+            versionConstraint = versionStr.element ? makeRange(versionStr.element) : undefined;
+            info = skipWhitespace(versionStr);
+        }
+    }
+    const licenseInfo = (0, objects_1.compactRecord)({
+        type: 'license',
+        license: licenseName.element,
+        versionConstraint
+    });
+    return { ...info, element: licenseInfo };
+}
+const operators = {
+    'and': ['and', '+', '&'],
+    'or': ['or', '|'],
+    'with': ['with']
+};
+function parseBinaryOperator(info) {
+    const license = parseLicenseElement(info);
+    info = skipWhitespace(license);
+    const operator = tryConsumeOperator(info);
+    if (operator.element) {
+        info = skipWhitespace(operator);
+        let rightLicense = parseLicenseInfo(info);
+        if (operator.element === 'with' && rightLicense.element.type === 'license') {
+            rightLicense = {
+                ...rightLicense,
+                element: {
+                    type: 'exception',
+                    exception: rightLicense.element.license
+                }
+            };
+        }
+        const combination = {
+            type: 'combination',
+            combination: operator.element,
+            elements: [license.element, rightLicense.element]
+        };
+        return { ...rightLicense, element: combination };
+    }
+    return { ...info, element: license.element };
+}
+function tryConsumeOperator(info) {
+    for (const [opName, opSymbols] of Object.entries(operators)) {
+        for (const symbol of opSymbols) {
+            if (info.remInput.toLowerCase().startsWith(symbol)) {
+                const newInfo = {
+                    position: info.position + symbol.length,
+                    remInput: info.remInput.slice(symbol.length)
+                };
+                return { ...newInfo, element: opName };
+            }
+        }
+    }
+    return { ...info, element: undefined };
+}
+function consumeString(info, str) {
+    info = skipWhitespace(info);
+    if (info.remInput.startsWith(str)) {
+        const newInfo = {
+            position: info.position + str.length,
+            remInput: info.remInput.slice(str.length)
+        };
+        return { ...newInfo, element: true };
+    }
+    else {
+        return { ...info, element: false };
+    }
+}
+function consumeUntilString(info, str) {
+    let idx = info.remInput.indexOf(str);
+    if (idx === -1) {
+        idx = info.remInput.length;
+    }
+    const consumed = info.remInput.slice(0, idx);
+    const newInfo = {
+        position: info.position + idx,
+        remInput: info.remInput.slice(idx)
+    };
+    return { ...newInfo, element: consumed };
+}
+function consumeRegexp(info, regex) {
+    info = skipWhitespace(info);
+    const match = info.remInput.match(regex);
+    if (match && match.index === 0) {
+        const matchedStr = match[0];
+        const newInfo = {
+            position: info.position + matchedStr.length,
+            remInput: info.remInput.slice(matchedStr.length)
+        };
+        return { ...newInfo, element: matchedStr };
+    }
+    return { ...info, element: null };
+}
+//# sourceMappingURL=r-license.js.map

package/util/simple-df/dfg-ascii.d.ts

@@ -0,0 +1,5 @@
+import type { DataflowGraph } from '../../dataflow/graph/graph';
+/**
+ * Converts the given dataflow graph to an ASCII representation.
+ */
+export declare function dfgToAscii(dfg: DataflowGraph): string;

package/util/simple-df/dfg-ascii.js

@@ -0,0 +1,272 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dfgToAscii = dfgToAscii;
+const dagre_1 = require("dagre");
+const edge_1 = require("../../dataflow/graph/edge");
+const node_id_1 = require("../../r-bridge/lang-4.x/ast/model/processing/node-id");
+const vertex_1 = require("../../dataflow/graph/vertex");
+function combineAscii(has, add) {
+    if (has === ' ' || has === add) {
+        return add;
+    }
+    const [a, b] = [has, add].sort();
+    let res = add;
+    if (b === edgesChar.vertical && a === edgesChar.horizontal) {
+        res = '┼';
+    }
+    else if ((b === edgesChar.topRight || b === edgesChar.topLeft || b === '┬') && a === edgesChar.horizontal) {
+        res = '┬';
+    }
+    else if ((b === edgesChar.bottomRight || b === edgesChar.bottomLeft || b === '┴') && a === edgesChar.horizontal) {
+        res = '┴';
+    }
+    else if ((b === edgesChar.topRight || b === edgesChar.bottomRight || b === '┤') && a === edgesChar.vertical) {
+        res = '┤';
+    }
+    else if ((b === edgesChar.topLeft || b === edgesChar.bottomLeft || b === '├') && a === edgesChar.vertical) {
+        res = '├';
+    }
+    else if ((b === '┤' || b === '├') && a === edgesChar.horizontal) {
+        res = '┼';
+    }
+    else if ((b === '┬' || b === '┴') && a === edgesChar.vertical) {
+        res = '┼';
+    }
+    return res;
+}
+class AsciiCanvas {
+    filler;
+    grid;
+    shiftX;
+    shiftY;
+    constructor(filler = ' ', shiftX = 0, shiftY = 0) {
+        this.grid = [];
+        this.filler = filler;
+        this.shiftX = shiftX;
+        this.shiftY = shiftY;
+    }
+    set(x, y, char, overwrite = false) {
+        x += this.shiftX;
+        y += this.shiftY;
+        if (x < 0 || y < 0 || isNaN(x) || isNaN(y)) {
+            return;
+        }
+        while (this.grid.length <= y) {
+            this.grid.push([]);
+        }
+        while (this.grid[y].length <= x) {
+            this.grid[y].push(this.filler);
+        }
+        this.grid[y][x] = overwrite ? char : combineAscii(this.grid[y][x], char);
+    }
+    drawText(x, y, text) {
+        for (let i = 0; i < text.length; i++) {
+            this.set(x + i, y, text[i]);
+        }
+    }
+    toString() {
+        return this.grid.map(r => r.join('')).join('\n');
+    }
+}
+/**
+ * Converts the given dataflow graph to an ASCII representation.
+ */
+function dfgToAscii(dfg) {
+    const g = new dagre_1.graphlib.Graph();
+    const verts = Array.from(dfg.vertices(true));
+    g.setGraph({
+        nodesep: 1,
+        ranksep: 4,
+        edgesep: 0,
+        rankdir: verts.length < 15 ? 'LR' : 'TB',
+        ranker: 'longest-path',
+    });
+    for (const [id, v] of verts) {
+        let label = (0, node_id_1.recoverName)(id, dfg.idMap) ?? v.tag;
+        if (label.length < 3) {
+            label = label.padStart(2, ' ').padEnd(3, ' ');
+        }
+        g.setNode(String(id), {
+            label,
+            width: Math.max(3, label.length * 2),
+            height: 3,
+            shape: 'rectangle'
+        });
+    }
+    const edgesDone = new Set();
+    let longestId = 0;
+    for (const [from, edges] of dfg.edges()) {
+        longestId = Math.max(longestId, String(from).length);
+        for (const [to, { types }] of edges) {
+            if (!g.hasNode(String(from)) || !g.hasNode(String(to)) || edgesDone.has(`${to}-${from}`)) {
+                continue;
+            }
+            longestId = Math.max(longestId, String(to).length);
+            g.setEdge(String(from), String(to), (0, edge_1.edgeTypesToNames)(types));
+            edgesDone.add(`${from}-${to}`);
+        }
+    }
+    (0, dagre_1.layout)(g, {
+        minlen: 2
+    });
+    const canvas = new AsciiCanvas();
+    renderEdges(g, canvas);
+    renderVertices(dfg, g, canvas);
+    const lines = canvas.toString().split('\n').filter(line => line.trim() !== '');
+    const edgeLines = [];
+    // add all edges
+    for (const [from, edges] of dfg.edges()) {
+        for (const [to, { types }] of edges) {
+            if (!g.hasNode(String(from)) || !g.hasNode(String(to))) {
+                continue;
+            }
+            edgeLines.push(`${from.toString().padStart(longestId, ' ')} -> ${to.toString().padStart(longestId, ' ')}: ${Array.from((0, edge_1.edgeTypesToNames)(types)).join(', ')}`);
+        }
+    }
+    // always merge two edgelines with padding
+    if (edgeLines.length > 0) {
+        lines.push('Edges:');
+    }
+    const longestFirstLine = Math.max(...edgeLines.map(l => l.length));
+    for (let i = 0; i < edgeLines.length; i += 2) {
+        const line1 = edgeLines[i];
+        const line2 = edgeLines[i + 1];
+        if (line2) {
+            lines.push(line1.padEnd(Math.min(50, longestFirstLine), ' ') + line2);
+        }
+        else {
+            lines.push(line1);
+        }
+    }
+    return lines.join('\n');
+}
+const type2Edge = {
+    [vertex_1.VertexType.FunctionCall]: 'c',
+    [vertex_1.VertexType.Use]: 'u',
+    [vertex_1.VertexType.FunctionDefinition]: 'f',
+    [vertex_1.VertexType.VariableDefinition]: 'v',
+    [vertex_1.VertexType.Value]: '0'
+};
+function renderVertices(dfg, g, canvas) {
+    for (const nodeId of g.nodes()) {
+        const node = g.node(nodeId);
+        if (!node) {
+            continue;
+        }
+        const label = node.label;
+        const x = Math.round(node.x);
+        const y = Math.round(node.y);
+        const tag = dfg.getVertex((0, node_id_1.normalizeIdToNumberIfPossible)(nodeId))?.tag;
+        let e = '+';
+        if (tag && tag in type2Edge) {
+            e = type2Edge[tag];
+        }
+        canvas.drawText(x - 1, y - 1, `${e}${'-'.repeat(label.length)}${e}`);
+        canvas.drawText(x - 1 + Math.round(label.length / 2 - nodeId.length / 2), y - 1, `<${nodeId}>`);
+        canvas.drawText(x - 1, y, `|${label}|`);
+        canvas.drawText(x - 1, y + 1, `${e}${'-'.repeat(label.length)}${e}`);
+    }
+}
+const edgesChar = {
+    vertical: '│',
+    horizontal: '─',
+    topLeft: '┌',
+    topRight: '┐',
+    bottomLeft: '└',
+    bottomRight: '┘',
+};
+function determineCornerChar(lastDirection, px, py, tx, ty) {
+    if (px === tx) {
+        return edgesChar.vertical;
+    }
+    else if (py === ty) {
+        return edgesChar.horizontal;
+    }
+    else if (px < tx) {
+        if (py < ty) {
+            return lastDirection === 'horizontal' ? edgesChar.topRight : edgesChar.bottomLeft;
+        }
+        else {
+            return lastDirection === 'horizontal' ? edgesChar.bottomRight : edgesChar.topLeft;
+        }
+    }
+    else {
+        if (py < ty) {
+            return lastDirection === 'horizontal' ? edgesChar.topLeft : edgesChar.bottomRight;
+        }
+        else {
+            return lastDirection === 'horizontal' ? edgesChar.bottomLeft : edgesChar.topRight;
+        }
+    }
+}
+function renderEdges(g, canvas) {
+    const otherEdges = new Set();
+    for (const e of g.edges()) {
+        const edge = g.edge(e);
+        let points = edge.points;
+        // we rework edges into sequences of straight lines only, adding intermediate points as needed
+        const newPoints = [points[0]];
+        for (let i = 1; i < points.length; i++) {
+            const prev = points[i - 1];
+            const curr = points[i];
+            if (prev.x !== curr.x && prev.y !== curr.y) {
+                const intermediate = { x: prev.x, y: curr.y };
+                newPoints.push(intermediate);
+            }
+            newPoints.push(curr);
+        }
+        points = newPoints;
+        let lastDirection = null;
+        // let single edges overwrite themselves
+        const writtenPoints = new Set();
+        for (let i = 0; i < points.length - 1; i++) {
+            const p = points[i - 1] ?? points[i];
+            const a = points[i];
+            const b = points[i + 1];
+            const px = Math.round(p.x);
+            const py = Math.round(p.y);
+            const x1 = Math.round(a.x);
+            const y1 = Math.round(a.y);
+            const x2 = Math.round(b.x);
+            const y2 = Math.round(b.y);
+            if (x1 === x2) {
+                // vertical
+                const [start, end] = y1 < y2 ? [y1, y2] : [y2, y1];
+                for (let y = start; y <= end; y++) {
+                    const key = `${x1},${y}`;
+                    const overwrite = writtenPoints.has(key) && !otherEdges.has(key);
+                    if (y === (y1 < y2 ? start : end)) {
+                        const cornerChar = determineCornerChar(lastDirection, px, py, x2, y2);
+                        canvas.set(x1, y, cornerChar, overwrite);
+                    }
+                    else {
+                        canvas.set(x1, y, edgesChar.vertical, overwrite);
+                    }
+                    writtenPoints.add(`${x1},${y}`);
+                }
+                lastDirection = 'vertical';
+            }
+            else if (y1 === y2) {
+                // horizontal
+                const [start, end] = x1 < x2 ? [x1, x2] : [x2, x1];
+                for (let x = start; x <= end; x++) {
+                    const key = `${x},${y1}`;
+                    const overwrite = writtenPoints.has(key) && !otherEdges.has(key);
+                    if (x === (x1 < x2 ? start : end)) {
+                        const cornerChar = determineCornerChar(lastDirection, px, py, x2, y2);
+                        canvas.set(x, y1, cornerChar, overwrite);
+                    }
+                    else {
+                        canvas.set(x, y1, edgesChar.horizontal, overwrite);
+                    }
+                    writtenPoints.add(`${x},${y1}`);
+                }
+                lastDirection = 'horizontal';
+            }
+        }
+        for (const p of writtenPoints) {
+            otherEdges.add(p);
+        }
+    }
+}
+//# sourceMappingURL=dfg-ascii.js.map

package/util/version.js

@@ -6,7 +6,7 @@ exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
 const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.7.4';
+const version = '2.7.6';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */