@lakutata/cli 2.17.1 → 3.0.0-beta.0

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

@@ -0,0 +1,357 @@
+import { readFile } from 'node:fs/promises';
+import { applyEdits, indentUnit, lineEndOf, lineIndent, NativeSyntaxError } from './TextEdits.js';
+/**
+ * The blocks of CMake, by their opening command
+ */
+const BLOCKS = { if: 'endif', foreach: 'endforeach', while: 'endwhile', function: 'endfunction', macro: 'endmacro', block: 'endblock' };
+/**
+ * The parser of the files of CMake, by the grammar of cmake-language(7): the command invocations, their bracket, quoted
+ * and unquoted arguments (the parentheses nested), the line and the bracket comments
+ */
+class CMakeParser {
+    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);
+    }
+    /**
+     * The length of the bracket opening at an offset ([==[: its = counted), -1 when there is none
+     * @param offset
+     */
+    bracketLevel(offset) {
+        if (this.text[offset] !== '[')
+            return -1;
+        let end = offset + 1;
+        while (this.text[end] === '=')
+            end++;
+        return this.text[end] === '[' ? end - offset - 1 : -1;
+    }
+    /**
+     * Skip a bracket ([=[…]=]) at the offset, return its content
+     */
+    bracket() {
+        const start = this.offset;
+        const level = this.bracketLevel(this.offset);
+        const close = `]${'='.repeat(level)}]`;
+        const contentStart = this.offset + level + 2;
+        const end = this.text.indexOf(close, contentStart);
+        if (end < 0)
+            this.error('unterminated bracket', start);
+        this.offset = end + close.length;
+        //The newline right after the opening bracket is not part of its content
+        return this.text.slice(contentStart, end).replace(/^\r?\n/, '');
+    }
+    /**
+     * Skip a comment at the offset (#…, #[[…]])
+     */
+    comment() {
+        this.offset++;
+        if (this.bracketLevel(this.offset) >= 0) {
+            this.bracket();
+        }
+        else {
+            while (this.offset < this.text.length && this.text[this.offset] !== '\n')
+                this.offset++;
+        }
+    }
+    /**
+     * Skip the spaces, the newlines and the comments
+     */
+    skip() {
+        for (;;) {
+            const char = this.text[this.offset];
+            if (char === ' ' || char === '\t' || char === '\r' || char === '\n')
+                this.offset++;
+            else if (char === '#')
+                this.comment();
+            else
+                return;
+        }
+    }
+    parse() {
+        const commands = [];
+        let depth = 0;
+        for (;;) {
+            this.skip();
+            if (this.offset >= this.text.length)
+                return commands;
+            const start = this.offset;
+            const identifier = /^[A-Za-z_][A-Za-z0-9_]*/.exec(this.text.slice(this.offset));
+            if (!identifier)
+                this.error(`unexpected ${JSON.stringify(this.text[this.offset])}`);
+            this.offset += identifier[0].length;
+            while (this.text[this.offset] === ' ' || this.text[this.offset] === '\t')
+                this.offset++;
+            if (this.text[this.offset] !== '(')
+                this.error('expected "(" after the name of the command');
+            this.offset++;
+            const args = this.arguments();
+            const name = identifier[0].toLowerCase();
+            //The commands closing a block are at the depth of their opening one
+            if (Object.values(BLOCKS).includes(name))
+                depth = Math.max(0, depth - 1);
+            commands.push({ name: name, args: args, start: start, end: this.offset, depth: ['else', 'elseif'].includes(name) ? Math.max(0, depth - 1) : depth });
+            if (name in BLOCKS)
+                depth++;
+        }
+    }
+    /**
+     * The arguments of a command, until its closing parenthesis (the parentheses nested are unquoted arguments)
+     */
+    arguments() {
+        const args = [];
+        let nested = 0;
+        for (;;) {
+            this.skip();
+            if (this.offset >= this.text.length)
+                this.error('unterminated command');
+            const char = this.text[this.offset];
+            const start = this.offset;
+            if (char === ')') {
+                this.offset++;
+                if (nested === 0)
+                    return args;
+                nested--;
+                args.push({ kind: 'unquoted', value: ')', start: start, end: this.offset });
+            }
+            else if (char === '(') {
+                this.offset++;
+                nested++;
+                args.push({ kind: 'unquoted', value: '(', start: start, end: this.offset });
+            }
+            else if (char === '[' && this.bracketLevel(this.offset) >= 0) {
+                args.push({ kind: 'bracket', value: this.bracket(), start: start, end: this.offset });
+            }
+            else if (char === '"') {
+                args.push({ kind: 'quoted', value: this.quoted(), start: start, end: this.offset });
+            }
+            else {
+                args.push({ kind: 'unquoted', value: this.unquoted(), start: start, end: this.offset });
+            }
+        }
+    }
+    quoted() {
+        const start = this.offset;
+        this.offset++;
+        let value = '';
+        for (;;) {
+            if (this.offset >= this.text.length)
+                this.error('unterminated quoted argument', start);
+            const char = this.text[this.offset];
+            if (char === '"') {
+                this.offset++;
+                return value;
+            }
+            if (char === '\\') {
+                const next = this.text[this.offset + 1] ?? '';
+                //A line continuation, an encoded escape, or the character escaped
+                value += next === '\n' ? '' : next === 't' ? '\t' : next === 'r' ? '\r' : next === 'n' ? '\n' : next === ';' ? '\;' : next;
+                this.offset += 2;
+                continue;
+            }
+            value += char;
+            this.offset++;
+        }
+    }
+    /**
+     * An unquoted argument: its characters but the whitespaces and ()#"\ (escaped by \), with the quoted parts of the
+     * legacy arguments (-Da="b c")
+     */
+    unquoted() {
+        let value = '';
+        for (;;) {
+            const char = this.text[this.offset];
+            if (char === undefined || /[\s()#]/.test(char))
+                return value;
+            if (char === '\\') {
+                value += this.text.slice(this.offset, this.offset + 2);
+                this.offset += 2;
+            }
+            else if (char === '"') {
+                //The quotes inside of a legacy unquoted argument
+                const end = this.text.indexOf('"', this.offset + 1);
+                if (end < 0)
+                    this.error('unterminated quote');
+                value += this.text.slice(this.offset, end + 1);
+                this.offset = end + 1;
+            }
+            else {
+                value += char;
+                this.offset++;
+            }
+        }
+    }
+}
+/**
+ * A file of CMake (CMakeLists.txt), parsed with the places of its commands: it is changed by edits of its text, its
+ * comments and its layout kept
+ */
+export class CMakeDocument {
+    constructor(file, text) {
+        this.file = file;
+        this.text = text;
+        this.edits = [];
+        this.commands = new CMakeParser(file, text).parse();
+        this.indent = indentUnit(text);
+    }
+    static async read(file) {
+        return new CMakeDocument(file, await readFile(file, 'utf8'));
+    }
+    get changes() {
+        return this.edits;
+    }
+    /**
+     * The document with its changes (parsed again)
+     */
+    applied() {
+        return new CMakeDocument(this.file, applyEdits(this.text, this.edits));
+    }
+    /**
+     * The value of an argument, its variables resolved (${PROJECT_NAME}, the variables set at the top level)
+     * @param value
+     */
+    resolve(value) {
+        const variables = new Map();
+        for (const command of this.commands) {
+            if (command.depth !== 0)
+                continue;
+            if (command.name === 'project' && command.args[0])
+                variables.set('PROJECT_NAME', command.args[0].value);
+            if (command.name === 'set' && command.args.length === 2)
+                variables.set(command.args[0].value, command.args[1].value);
+        }
+        return value.replace(/\$\{([A-Za-z0-9_]+)\}/g, (all, name) => variables.get(name) ?? all);
+    }
+    /**
+     * The targets of the libraries and the executables: their name, and the text naming them in their command
+     */
+    targets() {
+        return this.commands
+            .filter((command) => (command.name === 'add_library' || command.name === 'add_executable') && command.args.length > 0)
+            .map((command) => ({
+            name: this.resolve(command.args[0].value),
+            text: this.text.slice(command.args[0].start, command.args[0].end),
+            command: command
+        }));
+    }
+    /**
+     * The target changed: the one named, the only one by default
+     * @param name
+     */
+    target(name) {
+        const targets = this.targets();
+        if (!targets.length)
+            throw new Error(`${this.file} declares no target (add_library)`);
+        if (name !== undefined) {
+            const target = targets.find((candidate) => candidate.name === name);
+            if (!target)
+                throw new Error(`${this.file} has no target ${name} (${targets.map((candidate) => candidate.name).join(', ')})`);
+            return target;
+        }
+        if (targets.length > 1)
+            throw new Error(`${this.file} has several targets (${targets.map((candidate) => candidate.name).join(', ')}): --target gives the one changed`);
+        return targets[0];
+    }
+    /**
+     * Whether a command with these arguments exists (the arguments compared by their resolved values)
+     * @param name
+     * @param args
+     */
+    has(name, args) {
+        const expected = args.map((arg) => this.resolve(arg.replace(/^"(.*)"$/, '$1')));
+        return this.commands.some((command) => command.name === name.toLowerCase() &&
+            command.args.length === expected.length &&
+            command.args.every((arg, index) => this.resolve(arg.value) === expected[index]));
+    }
+    /**
+     * Insert commands after the last command of the top level about a target (its add_library, its target_* and
+     * set_target_properties commands, the add_custom_command of the target), on lines of their own
+     * @param target
+     * @param lines the commands, a line each
+     * @param condition the condition of the if block they are given in
+     */
+    insertAfterTarget(target, lines, condition) {
+        const about = this.commands.filter((command) => command.depth === 0 && (command === target.command ||
+            ((command.name.startsWith('target_') || command.name === 'set_target_properties') && command.args[0] !== undefined && this.resolve(command.args[0].value) === target.name) ||
+            (command.name === 'add_custom_command' && command.args[0]?.value.toUpperCase() === 'TARGET' && command.args[1] !== undefined && this.resolve(command.args[1].value) === target.name)));
+        //Inside of the block of the condition about the target already written
+        if (condition !== undefined) {
+            const block = this.conditionBlock(target, condition);
+            if (block) {
+                const last = this.commands[this.commands.indexOf(block) - 1];
+                const indent = this.commands[this.commands.indexOf(block) - 1].depth === 1 ? lineIndent(this.text, last.start) : lineIndent(this.text, block.start) + this.indent;
+                this.edits.push({ offset: lineEndOf(this.text, last.end), remove: 0, insert: `\n${lines.map((line) => `${indent}${line}`).join('\n')}` });
+                return;
+            }
+        }
+        //The block of a condition: the if blocks of the target are followed by the next one
+        const anchor = this.blockEnd(about.at(-1));
+        const indent = lineIndent(this.text, anchor.start);
+        const block = condition === undefined
+            ? lines.map((line) => `${indent}${line}`).join('\n')
+            : [`${indent}if(${condition})`, ...lines.map((line) => `${indent}${this.indent}${line}`), `${indent}endif()`].join('\n');
+        this.edits.push({ offset: lineEndOf(this.text, anchor.end), remove: 0, insert: `\n${block}` });
+    }
+    /**
+     * The endif of a block of the top level with a condition, after the target, holding only commands about it (its if
+     * has no else)
+     * @param target
+     * @param condition
+     */
+    conditionBlock(target, condition) {
+        const normalize = (text) => text.replace(/\s+/g, ' ').trim();
+        for (let index = this.commands.indexOf(target.command) + 1; index < this.commands.length; index++) {
+            const command = this.commands[index];
+            if (command.name !== 'if' || command.depth !== 0)
+                continue;
+            const open = this.text.indexOf('(', command.start);
+            if (normalize(this.text.slice(open + 1, command.end - 1)) !== normalize(condition))
+                continue;
+            let end = index + 1;
+            let about = true;
+            while (end < this.commands.length && !(this.commands[end].depth === 0 && this.commands[end].name === 'endif')) {
+                const inner = this.commands[end];
+                if (inner.depth === 0)
+                    about = false;
+                else if (inner.depth === 1 && !(['find_package', 'pkg_check_modules'].includes(inner.name) || (['target_link_libraries', 'target_include_directories', 'target_compile_definitions', 'set_target_properties', 'add_custom_command'].includes(inner.name) &&
+                    [inner.args[0]?.value, inner.args[1]?.value].some((arg) => arg !== undefined && this.resolve(arg) === target.name))))
+                    about = false;
+                end++;
+            }
+            if (about && end > index + 1 && end < this.commands.length)
+                return this.commands[end];
+        }
+        return undefined;
+    }
+    /**
+     * The last command of the if blocks following a command (the conditions about a target written after it)
+     * @param command
+     */
+    blockEnd(command) {
+        let index = this.commands.indexOf(command);
+        for (;;) {
+            const next = this.commands[index + 1];
+            if (next?.name !== 'if' || next.depth !== 0)
+                return this.commands[index];
+            //The block, until its endif
+            let end = index + 2;
+            while (end < this.commands.length && !(this.commands[end].name === 'endif' && this.commands[end].depth === 0))
+                end++;
+            //Its commands are about the target only when the first one is
+            const first = this.commands[index + 2];
+            if (!first || first.depth !== 1 || !(first.name.startsWith('target_') || ['set_target_properties', 'add_custom_command', 'find_package', 'pkg_check_modules'].includes(first.name)))
+                return this.commands[index];
+            index = end;
+        }
+    }
+}
+/**
+ * An argument of CMake for a value: quoted when it has spaces, semicolons, parentheses or quotes
+ * @param value
+ */
+export function cMakeArgumentText(value) {
+    return /[\s;()#"\\]/.test(value) && !/^\$<.*>$/.test(value) ? `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"')}"` : value;
+}