@eagleoutice/flowr 2.7.3 → 2.7.5

package/util/r-author.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthorRole = void 0;
+exports.rAuthorInfoToReadable = rAuthorInfoToReadable;
+exports.parseRAuthorString = parseRAuthorString;
+const args_1 = require("./text/args");
+const assert_1 = require("./assert");
+const objects_1 = require("./objects");
+const retriever_1 = require("../r-bridge/retriever");
+/** https://r-pkgs.org/description.html#sec-description-authors-at-r */
+var AuthorRole;
+(function (AuthorRole) {
+    /** the creator or maintainer, the person you should bother if you have problems. Despite being short for “creator”, this is the correct role to use for the current maintainer, even if they are not the initial creator of the package. */
+    AuthorRole["Creator"] = "cre";
+    /** authors, those who have made significant contributions to the package. */
+    AuthorRole["Author"] = "aut";
+    /** contributors, those who have made smaller contributions, like patches. */
+    AuthorRole["Contributor"] = "ctb";
+    /**  copyright holder. This is used to list additional copyright holders who are not authors, typically companies, like an employer of one or more of the authors. */
+    AuthorRole["CopyrightHolder"] = "cph";
+    /** funder, the people or organizations that have provided financial support for the development of the package. */
+    AuthorRole["Funder"] = "fnd";
+})(AuthorRole || (exports.AuthorRole = AuthorRole = {}));
+/**
+ * Convert structured R author information into an R `Authors@R` string.
+ */
+function rAuthorInfoToReadable(author) {
+    const nameStr = author.name.join(' ');
+    const emailStr = author.email ? ` <${author.email}>` : '';
+    const rolesStr = author.roles.length > 0 ? ` [${author.roles.join(', ')}]` : '';
+    const orcidStr = author.orcid ? ` (ORCID: ${author.orcid})` : '';
+    const commentStr = author.comment && author.comment.length > 0 ? ` {${author.comment.join('; ')}}` : '';
+    return `${nameStr}${emailStr}${rolesStr}${orcidStr}${commentStr}`;
+}
+/**
+ * Parse an R `Authors@R` string into structured author information.
+ * These are mostly found in `R` DESCRIPTION files and are a vector of `person()` calls.
+ * For now, this works *without* the full dataflow engine, so complex cases may not be parsed correctly.
+ */
+function parseRAuthorString(authorString) {
+    const str = authorString.trim();
+    if (str.startsWith('c(') && str.endsWith(')')) {
+        const inner = str.slice(2, -1).trim();
+        const parts = joinPartsWithVectors((0, args_1.splitAtEscapeSensitive)(inner, false, ','));
+        const authors = [];
+        for (const part of parts) {
+            const author = parseRPersonCall(part);
+            if (author) {
+                authors.push(author);
+            }
+        }
+        return authors;
+    }
+    else if (str.startsWith('person(') && str.endsWith(')')) {
+        const author = parseRPersonCall(str);
+        return author ? [author] : [];
+    }
+    return [];
+}
+function splitArgNameValue(arg) {
+    const eqIndex = arg.indexOf('=');
+    if (eqIndex === -1) {
+        const trimmedArg = arg.trim();
+        return { value: trimmedArg.length === 0 ? undefined : trimmedArg };
+    }
+    else {
+        const name = arg.slice(0, eqIndex).trim();
+        const value = arg.slice(eqIndex + 1).trim();
+        return { name, value };
+    }
+}
+// Joins parts that may be split by c(...) vectors back together, ...
+function joinPartsWithVectors(parts) {
+    const result = [];
+    let buffer = [];
+    let parenthesisLevel = 0;
+    for (const part of parts) {
+        const trimmed = part.trim();
+        // check whether parenthesis are balanced
+        for (const char of trimmed) {
+            if (char === '(') {
+                parenthesisLevel++;
+            }
+            else if (char === ')') {
+                parenthesisLevel--;
+            }
+        }
+        if (parenthesisLevel === 0) {
+            buffer.push(trimmed);
+            result.push(buffer.join(', '));
+            buffer = [];
+        }
+        else {
+            buffer.push(trimmed);
+        }
+    }
+    if (buffer.length > 0) {
+        result.push(buffer.join(', '));
+    }
+    return result;
+}
+const defaultPosArgNames = ['given', 'family', 'middle', 'email', 'role', 'comment', 'first', 'last'];
+function splitVector(roleStr) {
+    if (roleStr.startsWith('c(') && roleStr.endsWith(')')) {
+        const inner = roleStr.slice(2, -1).trim();
+        return joinPartsWithVectors((0, args_1.splitAtEscapeSensitive)(inner, false, ','));
+    }
+    else {
+        return [roleStr.trim()];
+    }
+}
+function parseRoles(roleStr) {
+    if (!roleStr) {
+        return [];
+    }
+    const roles = [];
+    const parts = splitVector(roleStr);
+    for (const part of parts) {
+        const trimmed = part.trim();
+        const roleValue = (0, retriever_1.removeRQuotes)(trimmed);
+        if (Object.values(AuthorRole).includes(roleValue)) {
+            roles.push(roleValue);
+        }
+    }
+    return roles;
+}
+function parseComments(commentStr) {
+    if (!commentStr) {
+        return undefined;
+    }
+    const comments = [];
+    const parts = splitVector(commentStr);
+    let orcid = undefined;
+    for (const part of parts) {
+        const trimmed = part.trim();
+        const commentValue = (0, retriever_1.removeRQuotes)(trimmed);
+        if (/ORCID\s*=/ig.test(commentValue)) {
+            const orcidIndex = commentValue.indexOf('=');
+            if (orcidIndex !== -1) {
+                orcid = (0, retriever_1.removeRQuotes)(commentValue.slice(orcidIndex + 1).trim());
+            }
+            continue;
+        }
+        comments.push(commentValue);
+    }
+    return comments.length > 0 || orcid ? { contents: comments, orcid: orcid } : undefined;
+}
+function assignArg(argMap, split) {
+    argMap.set(split.name, split.value === undefined || split.value?.length === 0 ? undefined : (0, retriever_1.removeRQuotes)(split.value));
+}
+function parseRPersonCall(personCall) {
+    /* function(given = NULL, family = NULL, middle = NULL,
+         email = NULL, role = NULL, comment = NULL,
+         first = NULL, last = NULL), but we neither use nor support full R semantics here for now */
+    personCall = personCall.trim();
+    if (!personCall.startsWith('person(') || !personCall.endsWith(')')) {
+        return undefined;
+    }
+    const inner = personCall.slice(7, -1).trim();
+    // these may also split unescaped commas inside c(...)
+    const parArgs = joinPartsWithVectors((0, args_1.splitAtEscapeSensitive)(inner, false, ','));
+    const argMap = new Map();
+    const unnamed = [];
+    for (const arg of parArgs) {
+        const split = splitArgNameValue(arg.trim());
+        if (!split.name) {
+            unnamed.push(arg.trim());
+            continue;
+        }
+        assignArg(argMap, split);
+    }
+    // assign unnamed args in order
+    for (let i = 0; i < unnamed.length; i++) {
+        if (i >= defaultPosArgNames.length) {
+            break;
+        }
+        const argIdx = defaultPosArgNames.findIndex(x => !argMap.has(x));
+        if (argIdx === -1) {
+            break;
+        }
+        const argName = defaultPosArgNames[argIdx];
+        const value = unnamed[i];
+        assignArg(argMap, { name: argName, value });
+    }
+    const comments = parseComments(argMap.get('comment'));
+    return (0, objects_1.compactRecord)({
+        name: [argMap.get('given') ?? argMap.get('first'), argMap.get('middle'), argMap.get('family') ?? argMap.get('last')].filter(assert_1.isNotUndefined),
+        email: argMap.get('email'),
+        roles: parseRoles(argMap.get('role')),
+        comment: comments?.contents,
+        orcid: comments?.orcid
+    });
+}
+//# sourceMappingURL=r-author.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.3';
+const version = '2.7.5';
 /**
  * Retrieves the current flowR version as a new {@link SemVer} object.
  */