@lakutata/cli 2.17.1 → 3.0.0-beta.0

package/dist/esm/lib/native/Gyp.js

@@ -0,0 +1,398 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { applyEdits, indentUnit, lineEndOf, lineIndent, NativeSyntaxError } from './TextEdits.js';
+/**
+ * The parser of the Python literals of the gyp files: comments (#), strings ('', "", ''' ''', """ """, the prefixes r,
+ * u, b, the adjacent strings concatenated as Python does), numbers, names (True, False, None), lists, tuples and
+ * dictionaries, their trailing commas
+ */
+class GypParser {
+    constructor(file, text) {
+        this.file = file;
+        this.text = text;
+        this.offset = 0;
+    }
+    error(message, offset = this.offset) {
+        throw new NativeSyntaxError(this.file, this.text, offset, message);
+    }
+    /**
+     * Skip the whitespaces, the line continuations and the comments
+     */
+    skip() {
+        for (;;) {
+            const char = this.text[this.offset];
+            if (char === ' ' || char === '\t' || char === '\r' || char === '\n' || char === '\f') {
+                this.offset++;
+            }
+            else if (char === '\\' && (this.text[this.offset + 1] === '\n' || this.text.startsWith('\r\n', this.offset + 1))) {
+                this.offset += this.text[this.offset + 1] === '\n' ? 2 : 3;
+            }
+            else if (char === '#') {
+                while (this.offset < this.text.length && this.text[this.offset] !== '\n')
+                    this.offset++;
+            }
+            else {
+                return;
+            }
+        }
+    }
+    parse() {
+        this.skip();
+        const node = this.value();
+        this.skip();
+        if (this.offset < this.text.length)
+            this.error('unexpected text after the value');
+        return node;
+    }
+    value() {
+        const char = this.text[this.offset];
+        if (char === '{')
+            return this.dict();
+        if (char === '[')
+            return this.list(']');
+        if (char === '(')
+            return this.list(')');
+        if (char === '"' || char === '\'' || (/[rRuUbB]/.test(char ?? '') && /^[rRuUbB]{1,2}['"]/.test(this.text.slice(this.offset, this.offset + 3))))
+            return this.strings();
+        const other = /^(?:[+-]?(?:0[xX][0-9a-fA-F_]+|0[oO][0-7_]+|0[bB][01_]+|\d[\d_]*(?:\.\d*)?(?:[eE][+-]?\d+)?)|True|False|None)/.exec(this.text.slice(this.offset));
+        if (!other)
+            this.error(char === undefined ? 'unexpected end of the file' : `unexpected ${JSON.stringify(char)}`);
+        const start = this.offset;
+        this.offset += other[0].length;
+        return { kind: 'other', text: other[0], start: start, end: this.offset };
+    }
+    /**
+     * A string, and the strings adjacent to it (concatenated)
+     */
+    strings() {
+        const start = this.offset;
+        let value = this.string();
+        for (;;) {
+            const before = this.offset;
+            this.skip();
+            const char = this.text[this.offset];
+            if (char === '"' || char === '\'' || /^[rRuUbB]{1,2}['"]/.test(this.text.slice(this.offset, this.offset + 3))) {
+                value += this.string();
+            }
+            else {
+                this.offset = before;
+                break;
+            }
+        }
+        return { kind: 'string', value: value, start: start, end: this.offset };
+    }
+    /**
+     * One string literal
+     */
+    string() {
+        const prefix = /^[rRuUbB]{0,2}/.exec(this.text.slice(this.offset))[0];
+        const raw = /[rR]/.test(prefix);
+        this.offset += prefix.length;
+        const quote = this.text[this.offset];
+        const triple = this.text.startsWith(quote.repeat(3), this.offset);
+        const delimiter = triple ? quote.repeat(3) : quote;
+        const start = this.offset;
+        this.offset += delimiter.length;
+        let value = '';
+        for (;;) {
+            if (this.offset >= this.text.length)
+                this.error('unterminated string', start);
+            if (this.text.startsWith(delimiter, this.offset)) {
+                this.offset += delimiter.length;
+                return value;
+            }
+            const char = this.text[this.offset];
+            if (char === '\n' && !triple)
+                this.error('unterminated string', start);
+            if (char === '\\') {
+                const next = this.text[this.offset + 1] ?? '';
+                if (raw) {
+                    value += char + next;
+                }
+                else {
+                    const escapes = { 'n': '\n', 't': '\t', 'r': '\r', '\\': '\\', '\'': '\'', '"': '"', '\n': '', 'a': '\x07', 'b': '\b', 'f': '\f', 'v': '\v', '0': '\0' };
+                    value += next in escapes ? escapes[next] : char + next;
+                }
+                this.offset += 2;
+                continue;
+            }
+            value += char;
+            this.offset++;
+        }
+    }
+    list(close) {
+        const start = this.offset;
+        this.offset++;
+        const items = [];
+        let trailingComma = false;
+        for (;;) {
+            this.skip();
+            if (this.text[this.offset] === close)
+                break;
+            items.push(this.value());
+            trailingComma = false;
+            this.skip();
+            if (this.text[this.offset] === ',') {
+                this.offset++;
+                trailingComma = true;
+            }
+            else if (this.text[this.offset] !== close) {
+                this.error(`expected "," or "${close}"`);
+            }
+        }
+        const closeOffset = this.offset;
+        this.offset++;
+        return { kind: 'list', items: items, start: start, end: this.offset, close: closeOffset, trailingComma: trailingComma };
+    }
+    dict() {
+        const start = this.offset;
+        this.offset++;
+        const entries = [];
+        let trailingComma = false;
+        for (;;) {
+            this.skip();
+            if (this.text[this.offset] === '}')
+                break;
+            const key = this.value();
+            if (key.kind !== 'string')
+                this.error('the keys of gyp are strings', key.start);
+            this.skip();
+            if (this.text[this.offset] !== ':')
+                this.error('expected ":"');
+            this.offset++;
+            this.skip();
+            const value = this.value();
+            entries.push({ key: key, value: value });
+            trailingComma = false;
+            this.skip();
+            if (this.text[this.offset] === ',') {
+                this.offset++;
+                trailingComma = true;
+            }
+            else if (this.text[this.offset] !== '}') {
+                this.error('expected "," or "}"');
+            }
+        }
+        const closeOffset = this.offset;
+        this.offset++;
+        return { kind: 'dict', entries: entries, start: start, end: this.offset, close: closeOffset, trailingComma: trailingComma };
+    }
+}
+/**
+ * A gyp file (binding.gyp, a .gypi), parsed with the places of its values: it is changed by edits of its text, its
+ * comments and its layout kept
+ */
+export class GypDocument {
+    constructor(file, text) {
+        this.file = file;
+        this.text = text;
+        this.edits = [];
+        const root = new GypParser(file, text).parse();
+        if (root.kind !== 'dict')
+            throw new NativeSyntaxError(file, text, root.start, 'a gyp file is a dictionary');
+        this.root = root;
+        this.indent = indentUnit(text);
+        const strings = text.match(/(?<![\w\\])['"]/g) ?? [];
+        this.quote = strings.filter((quote) => quote === '"').length > strings.filter((quote) => quote === '\'').length ? '"' : '\'';
+    }
+    static async read(file) {
+        return new GypDocument(file, await readFile(file, 'utf8'));
+    }
+    /**
+     * The edits of the changes made
+     */
+    get changes() {
+        return this.edits;
+    }
+    /**
+     * A string of the file, in its quote
+     * @param value
+     */
+    literal(value) {
+        const escaped = value.replace(/\\/g, '\\\\').replace(/\n/g, '\\n');
+        //The other quote when the value has the quote of the file only (OS=="mac": 'OS=="mac"')
+        const quote = escaped.includes(this.quote) && !escaped.includes(this.quote === '"' ? '\'' : '"') ? (this.quote === '"' ? '\'' : '"') : this.quote;
+        return quote === '"' ? `"${escaped.replace(/"/g, '\\"')}"` : `'${escaped.replace(/'/g, '\\\'')}'`;
+    }
+    /**
+     * The value of a key of a dictionary
+     * @param dict
+     * @param key
+     */
+    static get(dict, key) {
+        //A key repeated is the last one (as the dictionaries of Python, gyp evaluating its files)
+        return [...dict.entries].reverse().find((entry) => entry.key.value === key)?.value;
+    }
+    /**
+     * The text of a value, indented for its place (the lines after the first one)
+     * @param value
+     * @param indent the indentation of its line
+     */
+    render(value, indent) {
+        if (typeof value === 'string')
+            return this.literal(value);
+        const inner = indent + this.indent;
+        if (Array.isArray(value)) {
+            if (!value.length)
+                return '[]';
+            //A condition as gyp writes it: ['OS=="mac"', {, its entries indented once, }] (on lines of its own when empty)
+            if (value.length === 2 && typeof value[0] === 'string' && value[1] !== null && typeof value[1] === 'object' && !Array.isArray(value[1])) {
+                const entries = Object.entries(value[1]);
+                return `[${this.literal(value[0])}, {\n${entries.map(([key, item]) => `${inner}${this.literal(key)}: ${this.render(item, inner)},\n`).join('').replace(/,\n$/, '\n')}${indent}}]`;
+            }
+            //The lists of strings on one line, the other ones a value per line
+            if (value.every((item) => typeof item === 'string'))
+                return `[${value.map((item) => this.render(item, inner)).join(', ')}]`;
+            return `[\n${value.map((item) => `${inner}${this.render(item, inner)}`).join(',\n')}\n${indent}]`;
+        }
+        const entries = Object.entries(value);
+        if (!entries.length)
+            return '{}';
+        return `{\n${entries.map(([key, item]) => `${inner}${this.literal(key)}: ${this.render(item, inner)}`).join(',\n')}\n${indent}}`;
+    }
+    /**
+     * Insert items at the end of a list or of a dictionary (their texts): after its last item, its comma added, or
+     * before its closing bracket when it is empty
+     * @param container
+     * @param texts the items (the entries of a dictionary: 'key': value), by their indentation
+     */
+    append(container, texts) {
+        const items = container.kind === 'list' ? container.items : container.entries.map((entry) => ({ start: entry.key.start, end: entry.value.end }));
+        const last = items.at(-1);
+        const multiline = this.text.slice(container.start, container.close).includes('\n');
+        if (!last) {
+            if (!multiline) {
+                this.edits.push({ offset: container.close, remove: 0, insert: texts.map((text) => text('')).join(', ') });
+                return;
+            }
+            //Before the closing bracket, on lines of their own, after the comments of the empty container
+            const indent = lineIndent(this.text, container.close) + this.indent;
+            const lineStart = this.text.lastIndexOf('\n', container.close - 1) + 1;
+            const lines = texts.map((text) => `${indent}${text(indent)}`).join(',\n');
+            this.edits.push(/^[ \t]*$/.test(this.text.slice(lineStart, container.close))
+                ? { offset: lineStart, remove: 0, insert: `${lines}\n` }
+                : { offset: container.close, remove: 0, insert: `\n${lines}\n${lineIndent(this.text, container.close)}` });
+            return;
+        }
+        //After the last item and its comma
+        const comma = this.text.indexOf(',', last.end);
+        const hasComma = container.trailingComma && comma >= 0 && comma < container.close;
+        const after = hasComma ? comma + 1 : last.end;
+        if (!multiline) {
+            this.edits.push({ offset: after, remove: 0, insert: `${hasComma ? '' : ','} ${texts.map((text) => text('')).join(', ')}${hasComma ? ',' : ''}` });
+            return;
+        }
+        const indent = lineIndent(this.text, last.start);
+        const lines = texts.map((text) => `${indent}${text(indent)}`).join(',\n');
+        //After the line of the last item, its comment kept on it (its comma added after the item)
+        const lineEnd = lineEndOf(this.text, after);
+        if (lineEnd < container.close && /^[ \t]*(#.*)?$/.test(this.text.slice(after, lineEnd))) {
+            if (!hasComma)
+                this.edits.push({ offset: last.end, remove: 0, insert: ',' });
+            this.edits.push({ offset: lineEnd, remove: 0, insert: `\n${lines}${hasComma ? ',' : ''}` });
+            return;
+        }
+        this.edits.push({ offset: after, remove: 0, insert: `${hasComma ? '' : ','}\n${lines}${hasComma ? ',' : ''}` });
+    }
+    /**
+     * The document with its changes (parsed again)
+     */
+    applied() {
+        return new GypDocument(this.file, applyEdits(this.text, this.edits));
+    }
+    /**
+     * Add values to the list of a key of a dictionary (created when missing), the values it has skipped
+     * @param dict
+     * @param key
+     * @param values
+     * @return whether the file is changed
+     */
+    addToList(dict, key, values) {
+        const existing = GypDocument.get(dict, key);
+        if (existing && existing.kind !== 'list')
+            throw new NativeSyntaxError(this.file, this.text, existing.start, `"${key}" is not a list`);
+        const present = new Set(existing ? existing.items.filter((item) => item.kind === 'string').map((item) => item.value) : []);
+        const missing = values.filter((value) => !present.has(value));
+        if (!missing.length)
+            return false;
+        if (existing) {
+            this.append(existing, missing.map((value) => () => this.literal(value)));
+        }
+        else {
+            this.append(dict, [(indent) => `${this.literal(key)}: ${this.render(missing, indent)}`]);
+        }
+        return true;
+    }
+    /**
+     * Add an entry to a dictionary (when its key is missing)
+     * @param dict
+     * @param key
+     * @param value
+     * @return whether the file is changed
+     */
+    addEntry(dict, key, value) {
+        if (GypDocument.get(dict, key))
+            return false;
+        this.append(dict, [(indent) => `${this.literal(key)}: ${this.render(value, indent)}`]);
+        return true;
+    }
+    /**
+     * Add an item to a list
+     * @param list
+     * @param value
+     */
+    addItem(list, value) {
+        this.append(list, [(indent) => this.render(value, indent)]);
+    }
+}
+/**
+ * The normalized text of a condition of gyp (OS=="mac" and OS == 'mac' are the same condition)
+ * @param condition
+ */
+export function normalizeCondition(condition) {
+    return condition.replace(/\s+/g, '').replace(/'/g, '"');
+}
+/**
+ * The target of a gyp file, and the file it is declared in: the targets of the file, or of the files it includes
+ * (the includes of its root, relative to it)
+ * @param file
+ * @param name the name of the target, the only one by default
+ */
+export async function findGypTarget(file, name) {
+    const found = [];
+    const visited = new Set();
+    const visit = async (current) => {
+        if (visited.has(current))
+            return;
+        visited.add(current);
+        const document = await GypDocument.read(current);
+        const targets = GypDocument.get(document.root, 'targets');
+        if (targets?.kind === 'list') {
+            for (const target of targets.items)
+                if (target.kind === 'dict')
+                    found.push({ document: document, target: target });
+        }
+        const includes = GypDocument.get(document.root, 'includes');
+        if (includes?.kind === 'list') {
+            for (const include of includes.items)
+                if (include.kind === 'string')
+                    await visit(path.resolve(path.dirname(current), include.value));
+        }
+    };
+    await visit(file);
+    const named = (entry) => {
+        const value = GypDocument.get(entry.target, 'target_name');
+        return value?.kind === 'string' ? value.value : undefined;
+    };
+    if (!found.length)
+        throw new Error(`${file} declares no target (in its targets, or in the files it includes)`);
+    if (name !== undefined) {
+        const target = found.find((entry) => named(entry) === name);
+        if (!target)
+            throw new Error(`${file} has no target ${name} (${found.map(named).join(', ')})`);
+        return target;
+    }
+    if (found.length > 1)
+        throw new Error(`${file} has several targets (${found.map(named).join(', ')}): --target gives the one changed`);
+    return found[0];
+}