nextlua 1.0.0

package/index.js

@@ -0,0 +1,110 @@
+const fs = require("fs");
+const path = require("path");
+const beautify = require("./src/main");
+
+const commandId = "nextlua.beautifyDocument";
+
+function beautifyText(input) {
+    return beautify(input);
+}
+
+function activate(context) {
+    const vscode = require("vscode");
+    const selector = [
+        { language: "lua", scheme: "file" },
+        { language: "lua", scheme: "untitled" },
+        { language: "luau", scheme: "file" },
+        { language: "luau", scheme: "untitled" }
+    ];
+
+    const formatProvider = vscode.languages.registerDocumentFormattingEditProvider(selector, {
+        provideDocumentFormattingEdits(document) {
+            const fullRange = new vscode.Range(
+                document.positionAt(0),
+                document.lineAt(document.lineCount - 1).range.end
+            );
+
+            return [
+                vscode.TextEdit.replace(fullRange, beautifyText(document.getText()))
+            ];
+        }
+    });
+
+    const command = vscode.commands.registerCommand(commandId, async () => {
+        const editor = vscode.window.activeTextEditor;
+        if (!editor) {
+            vscode.window.showInformationMessage("Open a Lua or Luau file first.");
+            return;
+        }
+
+        const document = editor.document;
+        const fullRange = new vscode.Range(
+            document.positionAt(0),
+            document.lineAt(document.lineCount - 1).range.end
+        );
+        const output = beautifyText(document.getText());
+
+        await editor.edit(editBuilder => {
+            editBuilder.replace(fullRange, output);
+        });
+    });
+
+    context.subscriptions.push(formatProvider, command);
+}
+
+function deactivate() {}
+
+function readStdin() {
+    return new Promise((resolve, reject) => {
+        let input = "";
+
+        process.stdin.setEncoding("utf8");
+        process.stdin.on("data", chunk => {
+            input += chunk;
+        });
+        process.stdin.on("end", () => resolve(input));
+        process.stdin.on("error", reject);
+    });
+}
+
+async function runCli(argv) {
+    const inputPath = argv[2];
+    const outputPath = argv[3];
+    let input;
+
+    if (inputPath) {
+        input = fs.readFileSync(path.resolve(inputPath), "utf8");
+    } else if (fs.existsSync("input.lua")) {
+        input = fs.readFileSync("input.lua", "utf8");
+    } else if (!process.stdin.isTTY) {
+        input = await readStdin();
+    } else {
+        throw new Error("Usage: node index.js [input.lua] [output.lua] or pipe Lua code through stdin.");
+    }
+
+    const output = beautifyText(input);
+
+    if (outputPath) {
+        fs.writeFileSync(path.resolve(outputPath), output, "utf8");
+    } else if (!inputPath && fs.existsSync("input.lua")) {
+        fs.writeFileSync("output.lua", output, "utf8");
+    } else {
+        process.stdout.write(output);
+        if (!output.endsWith("\n")) {
+            process.stdout.write("\n");
+        }
+    }
+}
+
+if (require.main === module) {
+    runCli(process.argv).catch(error => {
+        console.error(error.message);
+        process.exitCode = 1;
+    });
+}
+
+module.exports = {
+    activate,
+    deactivate,
+    beautifyText
+};

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "nextlua",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs"
+}

package/src/keywords.js

@@ -0,0 +1,11 @@
+module.exports = {
+    after: [
+        "do",
+        "then",
+        /(?:^|\s)(?:local\s+)?function\b\s*\([^)]*\)/
+    ],
+    before: [
+        "end",
+        "elseif"
+    ]
+};

package/src/main.js

@@ -0,0 +1,566 @@
+const indent = "    ";
+
+const multiCharTokens = [
+    "...",
+    "..=",
+    "..",
+    "==",
+    "~=",
+    "<=",
+    ">=",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "^=",
+    "::",
+    "//",
+    "->",
+    "<<",
+    ">>"
+];
+
+const blockMiddle = new Set(["else", "elseif"]);
+const blockEnd = new Set(["end", "until"]);
+const statementKeywords = new Set([
+    "local",
+    "return",
+    "break",
+    "continue",
+    "if",
+    "elseif",
+    "else",
+    "while",
+    "for",
+    "repeat",
+    "do",
+    "function"
+]);
+const reservedKeywords = new Set([
+    "and",
+    "break",
+    "continue",
+    "do",
+    "else",
+    "elseif",
+    "end",
+    "false",
+    "for",
+    "function",
+    "if",
+    "in",
+    "local",
+    "nil",
+    "not",
+    "or",
+    "repeat",
+    "return",
+    "then",
+    "true",
+    "until",
+    "while"
+]);
+const expressionContinuations = new Set([
+    "=",
+    "(",
+    "[",
+    "{",
+    ",",
+    ".",
+    ":",
+    "::",
+    "return",
+    "local",
+    "then",
+    "do",
+    "in",
+    "until",
+    "elseif",
+    "while",
+    "for",
+    "if",
+    "function",
+    "not",
+    "and",
+    "or"
+]);
+const binaryOperators = new Set([
+    "=",
+    "+",
+    "-",
+    "*",
+    "/",
+    "//",
+    "%",
+    "^",
+    "..",
+    "..=",
+    "==",
+    "~=",
+    "<=",
+    ">=",
+    "<",
+    ">",
+    "and",
+    "or",
+    "+=",
+    "-=",
+    "*=",
+    "/=",
+    "%=",
+    "^="
+]);
+
+function isIdentifierStart(ch) {
+    return /[A-Za-z_]/.test(ch);
+}
+
+function isIdentifierPart(ch) {
+    return /[A-Za-z0-9_]/.test(ch);
+}
+
+function isNumberStart(ch) {
+    return /\d/.test(ch);
+}
+
+function readLongBracket(input, index) {
+    const match = input.slice(index).match(/^\[(=*)\[/);
+    if (!match) {
+        return null;
+    }
+
+    const marker = match[1];
+    const closing = `]${marker}]`;
+    const end = input.indexOf(closing, index + match[0].length);
+    const closeIndex = end === -1 ? input.length : end + closing.length;
+
+    return {
+        value: input.slice(index, closeIndex),
+        nextIndex: closeIndex
+    };
+}
+
+function tokenize(input) {
+    const tokens = [];
+    let i = 0;
+
+    while (i < input.length) {
+        const ch = input[i];
+
+        if (/\s/.test(ch)) {
+            i++;
+            continue;
+        }
+
+        if (input.startsWith("--", i)) {
+            const longComment = readLongBracket(input, i + 2);
+            if (longComment) {
+                tokens.push(`--${longComment.value}`);
+                i = longComment.nextIndex;
+                continue;
+            }
+
+            let end = input.indexOf("\n", i);
+            if (end === -1) {
+                end = input.length;
+            }
+
+            tokens.push(input.slice(i, end));
+            i = end;
+            continue;
+        }
+
+        if (ch === '"' || ch === "'" || ch === "`") {
+            let value = ch;
+            i++;
+
+            while (i < input.length) {
+                value += input[i];
+                if (input[i] === ch && input[i - 1] !== "\\") {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+
+            tokens.push(value);
+            continue;
+        }
+
+        const longString = readLongBracket(input, i);
+        if (longString) {
+            tokens.push(longString.value);
+            i = longString.nextIndex;
+            continue;
+        }
+
+        const matchedMulti = multiCharTokens.find(token => input.startsWith(token, i));
+        if (matchedMulti) {
+            tokens.push(matchedMulti);
+            i += matchedMulti.length;
+            continue;
+        }
+
+        if (isIdentifierStart(ch)) {
+            let end = i + 1;
+            while (end < input.length && isIdentifierPart(input[end])) {
+                end++;
+            }
+            tokens.push(input.slice(i, end));
+            i = end;
+            continue;
+        }
+
+        if (isNumberStart(ch)) {
+            let end = i + 1;
+            while (end < input.length && /[A-Fa-f0-9_xX.]/.test(input[end])) {
+                end++;
+            }
+            tokens.push(input.slice(i, end));
+            i = end;
+            continue;
+        }
+
+        tokens.push(ch);
+        i++;
+    }
+
+    return tokens;
+}
+
+function isComment(token) {
+    return token.startsWith("--");
+}
+
+function isIdentifier(token) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(token);
+}
+
+function isLiteral(token) {
+    return /^["'`]/.test(token) || /^\d/.test(token) || token === "..." || token === "true" || token === "false" || token === "nil";
+}
+
+function canEndStatement(token) {
+    return (isIdentifier(token) && !reservedKeywords.has(token)) || isLiteral(token) || token === ")" || token === "]" || token === "}" || token === "end" || token === "break" || token === "continue";
+}
+
+function shouldStartNewStatement(token, prevToken) {
+    if (!prevToken || expressionContinuations.has(prevToken)) {
+        return false;
+    }
+
+    if (token === "then" || token === "do" || token === "until" || token === "in") {
+        return false;
+    }
+
+    return statementKeywords.has(token) || (isIdentifier(token) && !reservedKeywords.has(token));
+}
+
+function needsSpace(prev, current) {
+    if (!prev) {
+        return false;
+    }
+
+    if (current === "," || current === ";" || current === ")" || current === "]" || current === "}") {
+        return false;
+    }
+
+    if (prev === "(" || prev === "[" || prev === "{") {
+        return false;
+    }
+
+    if (current === "(") {
+        return false;
+    }
+
+    if (prev === "." || current === "." || prev === ":" || current === ":") {
+        return false;
+    }
+
+    if (prev === "::" || current === "::") {
+        return false;
+    }
+
+    if (prev === "#" || current === "#") {
+        return false;
+    }
+
+    if (binaryOperators.has(prev) || binaryOperators.has(current)) {
+        return true;
+    }
+
+    return true;
+}
+
+function renderLine(tokens) {
+    let text = "";
+    let prev = null;
+
+    for (const token of tokens) {
+        if (needsSpace(prev, token)) {
+            text += " ";
+        }
+        text += token;
+        prev = token;
+    }
+
+    return text.trim();
+}
+
+function beautify(input) {
+    const tokens = tokenize(input);
+    const lines = [];
+    let current = [];
+    let depth = 0;
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let pendingHeader = null;
+    let functionHeaderDepth = null;
+    const inlineIfStack = [];
+    const blockBases = [{ paren: 0, brace: 0, bracket: 0 }];
+    const tableStack = [];
+
+    function flushCurrent() {
+        if (!current.length) {
+            return;
+        }
+
+        lines.push({
+            depth: Math.max(0, depth),
+            text: renderLine(current)
+        });
+        current = [];
+    }
+
+    function currentBase() {
+        return blockBases[blockBases.length - 1];
+    }
+
+    function atStatementLevel() {
+        const base = currentBase();
+        return parenDepth === base.paren && braceDepth === base.brace && bracketDepth === base.bracket;
+    }
+
+    function isInlineIf(token, prevToken) {
+        if (token !== "if") {
+            return false;
+        }
+
+        if (!current.length) {
+            return false;
+        }
+
+        return !canEndStatement(prevToken);
+    }
+
+    function currentTable() {
+        return tableStack[tableStack.length - 1];
+    }
+
+    function enterBlock() {
+        blockBases.push({
+            paren: parenDepth,
+            brace: braceDepth,
+            bracket: bracketDepth
+        });
+    }
+
+    function leaveBlock() {
+        if (blockBases.length > 1) {
+            blockBases.pop();
+        }
+    }
+
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        const prevToken = current[current.length - 1];
+
+        if (isComment(token)) {
+            flushCurrent();
+            lines.push({
+                depth: Math.max(0, depth),
+                text: token
+            });
+            continue;
+        }
+
+        if (!inlineIfStack.length && atStatementLevel() && current.length && shouldStartNewStatement(token, prevToken) && canEndStatement(prevToken)) {
+            flushCurrent();
+        }
+
+        if (blockMiddle.has(token) && atStatementLevel()) {
+            if (token === "else" && inlineIfStack.length) {
+                inlineIfStack.pop();
+                current.push(token);
+                continue;
+            }
+
+            flushCurrent();
+            leaveBlock();
+            depth = Math.max(0, depth - 1);
+            current.push(token);
+            pendingHeader = token === "elseif" ? "then" : null;
+
+            if (token === "else") {
+                flushCurrent();
+                depth++;
+                enterBlock();
+            }
+            continue;
+        }
+
+        if (blockEnd.has(token) && atStatementLevel()) {
+            flushCurrent();
+            leaveBlock();
+            depth = Math.max(0, depth - 1);
+            current.push(token);
+
+            if (token === "until") {
+                continue;
+            }
+            continue;
+        }
+
+        current.push(token);
+
+        if (token === "(") {
+            parenDepth++;
+            if (functionHeaderDepth === null && current.includes("function")) {
+                functionHeaderDepth = parenDepth;
+            }
+            continue;
+        }
+
+        if (token === ")") {
+            parenDepth = Math.max(0, parenDepth - 1);
+            if (functionHeaderDepth !== null && parenDepth < functionHeaderDepth) {
+                functionHeaderDepth = null;
+                flushCurrent();
+                depth++;
+                enterBlock();
+            }
+            continue;
+        }
+
+        if (token === "{") {
+            braceDepth++;
+            const multiline = tokens[i + 1] !== "}";
+            tableStack.push({
+                brace: braceDepth,
+                paren: parenDepth,
+                bracket: bracketDepth,
+                blockDepth: blockBases.length,
+                multiline
+            });
+
+            if (multiline) {
+                flushCurrent();
+                depth++;
+            }
+            continue;
+        }
+
+        if (token === "}") {
+            const table = currentTable();
+            if (
+                table &&
+                table.multiline &&
+                braceDepth === table.brace &&
+                parenDepth === table.paren &&
+                bracketDepth === table.bracket &&
+                blockBases.length === table.blockDepth
+            ) {
+                current.pop();
+                flushCurrent();
+                depth = Math.max(0, depth - 1);
+                current.push(token);
+            }
+
+            braceDepth = Math.max(0, braceDepth - 1);
+            tableStack.pop();
+            continue;
+        }
+
+        if (token === "[") {
+            bracketDepth++;
+            continue;
+        }
+
+        if (token === "]") {
+            bracketDepth = Math.max(0, bracketDepth - 1);
+            continue;
+        }
+
+        if (token === ";") {
+            flushCurrent();
+            continue;
+        }
+
+        if (token === ",") {
+            const table = currentTable();
+            if (
+                table &&
+                table.multiline &&
+                braceDepth === table.brace &&
+                parenDepth === table.paren &&
+                bracketDepth === table.bracket &&
+                blockBases.length === table.blockDepth
+            ) {
+                flushCurrent();
+            }
+            continue;
+        }
+
+        if (isInlineIf(token, prevToken)) {
+            inlineIfStack.push("then");
+            continue;
+        }
+
+        if (token === "if" || token === "elseif") {
+            pendingHeader = "then";
+            continue;
+        }
+
+        if (token === "while" || token === "for") {
+            pendingHeader = "do";
+            continue;
+        }
+
+        if (token === "repeat") {
+            flushCurrent();
+            depth++;
+            enterBlock();
+            continue;
+        }
+
+        if (token === "do" && pendingHeader !== "do" && atStatementLevel()) {
+            flushCurrent();
+            depth++;
+            enterBlock();
+            continue;
+        }
+
+        if (token === "then" && inlineIfStack.length && inlineIfStack[inlineIfStack.length - 1] === "then") {
+            inlineIfStack[inlineIfStack.length - 1] = "else";
+            continue;
+        }
+
+        if ((token === "then" && pendingHeader === "then") || (token === "do" && pendingHeader === "do")) {
+            pendingHeader = null;
+            flushCurrent();
+            depth++;
+            enterBlock();
+            continue;
+        }
+    }
+
+    flushCurrent();
+
+    return lines
+        .map(line => `${indent.repeat(line.depth)}${line.text}`.trimEnd())
+        .join("\n");
+}
+
+module.exports = beautify;