@peter.prib/renderengine 0.2.5 → 0.2.7

package/src/yaml/YamlReader.js

@@ -0,0 +1,372 @@
+/**
+ * YamlReader — reads the block YAML that specifications are written in
+ * (OpenAPI and AsyncAPI files: BIAN's semantic APIs), dependency-free:
+ * mappings and sequences by indentation, a sequence item that is a mapping,
+ * plain, single- and double-quoted scalars (a plain one may run on over more
+ * indented lines), block scalars (`|` literal, `>` folded, chomping `-`/`+`,
+ * an indentation digit), flow collections (`[a, b]`, `{a: b}`, over several
+ * lines too), comments, and `---`/`...` around one document. Plain scalars are
+ * typed as YAML 1.2's core schema has them (null, booleans, numbers).
+ * Anchors, aliases, tags and multiple documents are not read: such a file is
+ * refused with the line it fails on.
+ */
+export class YamlReader {
+    /**
+     * @param {string} text
+     * @returns {*} the document's value
+     */
+    static parse(text) {
+        return new YamlReader(text).document();
+    }
+
+    constructor(text) {
+        this.lines = String(text).replace(/^/, '').split(/\r?\n/);
+        this.i = 0;
+        /** The line the value being read starts on. */
+        this.at = null;
+    }
+
+    document() {
+        this._skipBlank();
+        if (this.i < this.lines.length && /^---(\s|$)/.test(this.lines[this.i])) {
+            const rest = this.lines[this.i].slice(3).trim();
+            if (rest && !rest.startsWith('#')) this.lines[this.i] = rest; else this.i++;
+        }
+        this._skipBlank();
+        const value = this.i < this.lines.length ? this.node(0) : null;
+        this._skipBlank();
+        if (this.i < this.lines.length && !/^\.\.\.(\s|$)/.test(this.lines[this.i])) {
+            this.at = this.i;
+            this.fail(`Unexpected content at indentation ${this._indent(this.lines[this.i])}`);
+        }
+        return value;
+    }
+
+    /** Refuse the file, naming the line of the value being read. */
+    fail(message) {
+        throw new SyntaxError(`YAML line ${(this.at ?? this.i) + 1}: ${message}`);
+    }
+
+    /** Skip blank and comment-only lines. @private */
+    _skipBlank() {
+        while (this.i < this.lines.length && /^\s*(#.*)?$/.test(this.lines[this.i])) this.i++;
+    }
+
+    _indent(line) {
+        return line.length - line.trimStart().length;
+    }
+
+    /** The node whose first line is the next significant one, at least `min` deep. */
+    node(min) {
+        this._skipBlank();
+        if (this.i >= this.lines.length) return null;
+        const line = this.lines[this.i];
+        const indent = this._indent(line);
+        if (indent < min) return null;
+        const text = line.slice(indent);
+        if (/^-(\s|$)/.test(text)) return this.sequence(indent);
+        if (this._keyOf(text)) return this.mapping(indent);
+        this.i++;
+        return this.inline(text, indent - 1);
+    }
+
+    /** A sequence: items `- x` at `indent`. */
+    sequence(indent) {
+        const items = [];
+        for (;;) {
+            this._skipBlank();
+            if (this.i >= this.lines.length) break;
+            const line = this.lines[this.i];
+            if (this._indent(line) !== indent || !/^-(\s|$)/.test(line.slice(indent))) break;
+            const after = line.slice(indent + 1);
+            const gap = after.length - after.trimStart().length;
+            const rest = after.trim();
+            if (!rest || rest.startsWith('#')) {
+                this.i++;
+                items.push(this.node(indent + 1));
+                continue;
+            }
+            // What follows the dash is a node starting at its own column (a mapping's first key, another item).
+            const column = indent + 1 + gap;
+            if (/^-(\s|$)/.test(rest) || this._keyOf(rest)) {
+                this.lines[this.i] = ' '.repeat(column) + rest;
+                items.push(this.node(column));
+            } else {
+                this.i++;
+                items.push(this.inline(rest, indent));
+            }
+        }
+        return items;
+    }
+
+    /** A mapping: `key: value` lines at `indent`. */
+    mapping(indent) {
+        const map = {};
+        for (;;) {
+            this._skipBlank();
+            if (this.i >= this.lines.length) break;
+            const line = this.lines[this.i];
+            if (this._indent(line) !== indent) {
+                if (this._indent(line) > indent) {
+                    this.at = this.i;
+                    this.fail('Unexpected indentation');
+                }
+                break;
+            }
+            const text = line.slice(indent);
+            const key = this._keyOf(text);
+            if (!key) break;
+            const rest = text.slice(key.length).trim();
+            this.i++;
+            let value;
+            if (!rest || rest.startsWith('#')) {
+                this._skipBlank();
+                const next = this.lines[this.i];
+                // A sequence may sit at its key's own indentation.
+                if (next !== undefined && this._indent(next) === indent && /^-(\s|$)/.test(next.slice(indent))) value = this.sequence(indent);
+                else value = this.node(indent + 1);
+            } else {
+                value = this.inline(rest, indent);
+            }
+            map[this._keyName(key)] = value;
+        }
+        return map;
+    }
+
+    /**
+     * A key and its colon at the start of `text` (`name:`, `'quoted':`), or null.
+     * @private
+     */
+    _keyOf(text) {
+        let m;
+        if (text[0] === '"') m = /^"(?:[^"\\]|\\.)*"\s*:(?=\s|$)/.exec(text);
+        else if (text[0] === "'") m = /^'(?:[^']|'')*'\s*:(?=\s|$)/.exec(text);
+        else if (/^[[{|>!&*%@`#]/.test(text) || /^-(\s|$)/.test(text)) return null;
+        else m = /^[^#]*?:(?=\s|$)/.exec(text);
+        return m ? m[0] : null;
+    }
+
+    /** A key's name without its colon or quotes. @private */
+    _keyName(key) {
+        const raw = key.replace(/\s*:$/, '').trim();
+        return raw[0] === '"' || raw[0] === "'" ? this._quoted(raw) : raw;
+    }
+
+    /**
+     * A value written after its key or dash: a block scalar, a quoted or plain
+     * scalar (running on over lines deeper than `parent`), or a flow collection.
+     */
+    inline(text, parent) {
+        this.at = this.i - 1;
+        if (/^[|>]/.test(text)) return this.blockScalar(text, parent);
+        if (text[0] === '[' || text[0] === '{') return this.flow(text, parent);
+        if (text[0] === '"' || text[0] === "'") return this.quotedRunningOn(text, parent);
+        if (/^[&*!]/.test(text)) this.fail(`Anchors, aliases and tags are not read: "${text}"`);
+        const parts = [this._stripComment(text)];
+        while (this.i < this.lines.length) {
+            const line = this.lines[this.i];
+            if (/^\s*$/.test(line)) {
+                // A blank line inside a plain scalar is a line break, if the scalar goes on.
+                let j = this.i;
+                while (j < this.lines.length && /^\s*$/.test(this.lines[j])) j++;
+                if (j < this.lines.length && this._indent(this.lines[j]) > parent && !/^\s*#/.test(this.lines[j])) {
+                    parts.push('\n'.repeat(j - this.i));
+                    this.i = j;
+                    continue;
+                }
+                break;
+            }
+            if (this._indent(line) <= parent || /^\s*#/.test(line)) break;
+            const more = line.trim();
+            if (this._keyOf(more) || /^-(\s|$)/.test(more)) break;
+            parts.push(this._stripComment(more));
+            this.i++;
+        }
+        const joined = parts.reduce((all, p) => (p.startsWith('\n') ? all + p : all && !all.endsWith('\n') ? `${all} ${p}` : all + p), '');
+        return parts.length === 1 ? YamlReader.plain(joined) : joined;
+    }
+
+    _stripComment(text) {
+        return text.replace(/\s+#.*$/, '').trim();
+    }
+
+    /** A quoted scalar, its closing quote perhaps on a later line (lines folded). */
+    quotedRunningOn(text, parent) {
+        const quote = text[0];
+        const closed = quote === '"' ? /^"(?:[^"\\]|\\.)*"/ : /^'(?:[^']|'')*'/;
+        let all = text;
+        while (!closed.test(all)) {
+            if (this.i >= this.lines.length) this.fail('A quoted scalar is not closed');
+            const line = this.lines[this.i++];
+            all += /^\s*$/.test(line) ? '\n' : ` ${line.trim()}`;
+        }
+        const m = closed.exec(all);
+        const after = this._stripComment(all.slice(m[0].length));
+        if (after) this.fail(`Unexpected "${after}" after a quoted scalar`);
+        return this._quoted(m[0].replace(/ \n /g, '\n'));
+    }
+
+    /** A quoted scalar's value: double quotes with escapes, single quotes with '' for '. @private */
+    _quoted(raw) {
+        const body = raw.slice(1, -1);
+        if (raw[0] === "'") return body.replace(/''/g, "'");
+        const escapes = { n: '\n', r: '\r', t: '\t', '"': '"', '\\': '\\', '/': '/', 0: '\0', b: '\b', f: '\f', e: '\x1b', ' ': ' ', N: '\u0085', _: ' ' };
+        return body.replace(/\\(x[0-9a-fA-F]{2}|u[0-9a-fA-F]{4}|U[0-9a-fA-F]{8}|.)/g, (_, e) => {
+            if (/^[xuU]/.test(e) && e.length > 1) return String.fromCodePoint(parseInt(e.slice(1), 16));
+            return escapes[e] ?? e;
+        });
+    }
+
+    /** A block scalar (`|` or `>`, chomping, indentation digit), its lines deeper than `parent`. */
+    blockScalar(header, parent) {
+        const m = /^([|>])([-+]?)([1-9]?)([-+]?)\s*(#.*)?$/.exec(header);
+        if (!m) this.fail(`Not a block scalar header: "${header}"`);
+        const [, style, chompA, digit, chompB] = m;
+        const chomp = chompA || chompB;
+        const raw = [];
+        while (this.i < this.lines.length) {
+            const line = this.lines[this.i];
+            if (!/^\s*$/.test(line) && this._indent(line) <= parent) break;
+            raw.push(line);
+            this.i++;
+        }
+        // Trailing blank lines belong to the scalar only for chomping; keep them apart.
+        let end = raw.length;
+        while (end > 0 && /^\s*$/.test(raw[end - 1])) end--;
+        const body = raw.slice(0, end), trailing = raw.length - end;
+        const first = body.find(l => !/^\s*$/.test(l));
+        const indent = digit ? parent + Number(digit) : first !== undefined ? this._indent(first) : parent + 1;
+        const lines = body.map(l => (/^\s*$/.test(l) ? '' : l.slice(indent)));
+        let text;
+        if (style === '|') {
+            text = lines.join('\n');
+        } else {
+            text = '';
+            lines.forEach((line, k) => {
+                if (k === 0) { text = line; return; }
+                const prev = lines[k - 1];
+                const moreIndented = (s) => /^\s/.test(s);
+                if (line === '') text += '\n';
+                else if (prev === '' || moreIndented(line) || moreIndented(prev)) text += (prev === '' ? '' : '\n') + line;
+                else text += ` ${line}`;
+            });
+        }
+        if (!body.length) return chomp === '+' ? '\n'.repeat(trailing) : '';
+        if (chomp === '-') return text;
+        if (chomp === '+') return `${text}\n${'\n'.repeat(trailing)}`;
+        return `${text}\n`;
+    }
+
+    /** A flow collection, perhaps over several lines. */
+    flow(text, parent) {
+        let all = text;
+        const balanced = (s) => {
+            let depth = 0, quote = null;
+            for (let k = 0; k < s.length; k++) {
+                const c = s[k];
+                if (quote) {
+                    if (c === '\\' && quote === '"') k++;
+                    else if (c === quote) quote = null;
+                } else if (c === '"' || c === "'") quote = c;
+                else if (c === '[' || c === '{') depth++;
+                else if (c === ']' || c === '}') depth--;
+                else if (c === '#' && /\s/.test(s[k - 1] ?? ' ') && depth === 0) break;
+            }
+            return depth === 0;
+        };
+        while (!balanced(all)) {
+            if (this.i >= this.lines.length) this.fail('A flow collection is not closed');
+            all += ` ${this.lines[this.i++].trim()}`;
+        }
+        const reader = new FlowReader(all, (msg) => this.fail(msg), (raw) => this._quoted(raw));
+        const value = reader.value();
+        reader.space();
+        if (reader.pos < all.length && !all.slice(reader.pos).trim().startsWith('#')) this.fail(`Unexpected "${all.slice(reader.pos).trim()}" after a flow collection`);
+        return value;
+    }
+
+    /** A plain scalar's value, typed as YAML 1.2's core schema has it. */
+    static plain(text) {
+        if (/^(null|Null|NULL|~)?$/.test(text)) return null;
+        if (/^(true|True|TRUE)$/.test(text)) return true;
+        if (/^(false|False|FALSE)$/.test(text)) return false;
+        if (/^[-+]?[0-9]+$/.test(text)) return Number(text);
+        if (/^0x[0-9a-fA-F]+$/.test(text)) return parseInt(text, 16);
+        if (/^0o[0-7]+$/.test(text)) return parseInt(text.slice(2), 8);
+        if (/^[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?$/.test(text)) return Number(text);
+        if (/^[-+]?\.(inf|Inf|INF)$/.test(text)) return text.startsWith('-') ? -Infinity : Infinity;
+        if (/^\.(nan|NaN|NAN)$/.test(text)) return NaN;
+        return text;
+    }
+}
+
+/** Reads one flow collection (`[...]`, `{...}`) from a string. @private */
+class FlowReader {
+    constructor(text, fail, quoted) {
+        Object.assign(this, { text, fail, quoted, pos: 0 });
+    }
+
+    space() {
+        while (this.pos < this.text.length && /\s/.test(this.text[this.pos])) this.pos++;
+    }
+
+    value() {
+        this.space();
+        const c = this.text[this.pos];
+        if (c === '[') return this.list();
+        if (c === '{') return this.map();
+        if (c === '"' || c === "'") {
+            const m = (c === '"' ? /^"(?:[^"\\]|\\.)*"/ : /^'(?:[^']|'')*'/).exec(this.text.slice(this.pos));
+            if (!m) this.fail('A quoted scalar is not closed');
+            this.pos += m[0].length;
+            return this.quoted(m[0]);
+        }
+        const m = /^[^,\]}]*?(?=\s*(?:[,\]}]|:\s|$))/.exec(this.text.slice(this.pos));
+        this.pos += m[0].length;
+        return YamlReader.plain(m[0].trim());
+    }
+
+    list() {
+        this.pos++;
+        const items = [];
+        for (;;) {
+            this.space();
+            if (this.text[this.pos] === ']') { this.pos++; return items; }
+            items.push(this.entry());
+            this.space();
+            if (this.text[this.pos] === ',') this.pos++;
+            else if (this.text[this.pos] !== ']') this.fail('Expected , or ] in a flow sequence');
+        }
+    }
+
+    /** A flow sequence's entry: a value, or a single `key: value` pair (a one-key mapping). */
+    entry() {
+        const value = this.value();
+        this.space();
+        if (this.text[this.pos] === ':') {
+            this.pos++;
+            return { [String(value)]: this.value() };
+        }
+        return value;
+    }
+
+    map() {
+        this.pos++;
+        const map = {};
+        for (;;) {
+            this.space();
+            if (this.text[this.pos] === '}') { this.pos++; return map; }
+            const key = this.value();
+            this.space();
+            let value = null;
+            if (this.text[this.pos] === ':') {
+                this.pos++;
+                value = this.value();
+            }
+            map[String(key)] = value;
+            this.space();
+            if (this.text[this.pos] === ',') this.pos++;
+            else if (this.text[this.pos] !== '}') this.fail('Expected , or } in a flow mapping');
+        }
+    }
+}