pulse-rb 1.2.24

package/vscode/src/extension.js

@@ -0,0 +1,397 @@
+'use strict';
+
+const vscode = require('vscode');
+
+const VALID_SIDES = new Set(['left', 'right']);
+const KNOWN_EVENTS = new Set([
+    'Heartbeat', 'RenderStepped', 'Stepped',
+    'InputBegan', 'InputEnded', 'InputChanged',
+    'Respawn', 'Touched', 'TouchEnded',
+]);
+
+let _diag;
+
+// ─── Activation / Deactivation ───────────────────────────────────────────────
+
+function activate(context) {
+    _diag = vscode.languages.createDiagnosticCollection('rblua');
+    context.subscriptions.push(_diag);
+
+    context.subscriptions.push(
+        vscode.languages.registerDocumentFormattingEditProvider('rblua', {
+            provideDocumentFormattingEdits: doc => format(doc),
+        })
+    );
+
+    context.subscriptions.push(
+        vscode.languages.registerCompletionItemProvider(
+            'rblua',
+            { provideCompletionItems: (doc, pos) => completions(doc, pos) }
+        )
+    );
+
+    const lint = doc => { if (doc.languageId === 'rblua') lintDoc(doc); };
+    context.subscriptions.push(
+        vscode.workspace.onDidOpenTextDocument(lint),
+        vscode.workspace.onDidChangeTextDocument(e => lint(e.document)),
+        vscode.workspace.onDidCloseTextDocument(doc => _diag.delete(doc.uri)),
+    );
+    vscode.workspace.textDocuments.forEach(lint);
+}
+
+function deactivate() { if (_diag) _diag.dispose(); }
+
+module.exports = { activate, deactivate };
+
+// ─── Linter ──────────────────────────────────────────────────────────────────
+
+function lintDoc(doc) {
+    const text  = doc.getText();
+    const lines = text.split('\n');
+    const diags = [];
+
+    const stripped = blankStringsAndComments(text);
+    let depth = 0;
+    for (let i = 0; i < stripped.length; i++) {
+        const ch = stripped[i];
+        if (ch === '{') { depth++; continue; }
+        if (ch !== '}') continue;
+        depth--;
+        if (depth < 0) {
+            const pos = doc.positionAt(i);
+            diags.push(mkDiag(
+                new vscode.Range(pos, pos.translate(0, 1)),
+                'Unexpected closing brace', vscode.DiagnosticSeverity.Error));
+            depth = 0;
+        }
+    }
+    if (depth > 0) {
+        const last = new vscode.Position(Math.max(0, doc.lineCount - 1), 0);
+        diags.push(mkDiag(new vscode.Range(last, last),
+            `${depth} unclosed brace${depth > 1 ? 's' : ''}`, vscode.DiagnosticSeverity.Error));
+    }
+
+    let signals = new Set(), inComponent = false;
+    for (let ln = 0; ln < lines.length; ln++) {
+        const raw = lines[ln], line = raw.trim();
+        const rng = new vscode.Range(ln, 0, ln, raw.length);
+
+        if (/^component\s*\{/.test(line)) { inComponent = true; signals = new Set(); }
+
+        const sigM = line.match(/^signal\s+(\w+)\s*=\s*(.+)$/);
+        if (sigM) {
+            signals.add(sigM[1]);
+            const val = sigM[2].trim().replace(/\s*--.*$/, '');
+            if (!isLiteral(val))
+                diags.push(mkDiag(rng,
+                    `Signal default must be a string, number, or boolean — got: ${val}`,
+                    vscode.DiagnosticSeverity.Warning));
+            continue;
+        }
+
+        const onM = line.match(/^on\s+(\w+)/);
+        if (onM && inComponent && signals.size > 0) {
+            const name = onM[1];
+            if (/^[a-z]/.test(name) && !signals.has(name) && !KNOWN_EVENTS.has(name))
+                diags.push(mkDiag(rng,
+                    `'${name}' is not a declared signal in this component`,
+                    vscode.DiagnosticSeverity.Warning));
+        }
+
+        const gbM = line.match(/^groupbox\s+(\w+)\s+"/);
+        if (gbM && !VALID_SIDES.has(gbM[1]))
+            diags.push(mkDiag(rng,
+                `Groupbox side must be 'left' or 'right', got '${gbM[1]}'`,
+                vscode.DiagnosticSeverity.Error));
+    }
+
+    _diag.set(doc.uri, diags);
+}
+
+function isLiteral(v) {
+    return /^"[^"]*"$/.test(v) || /^'[^']*'$/.test(v)
+        || /^-?\d+(\.\d+)?([eE][+-]?\d+)?$/.test(v)
+        || v === 'true' || v === 'false' || v === 'nil'
+        || /^\{[^}]*\}$/.test(v);
+}
+function mkDiag(range, msg, severity) {
+    const d = new vscode.Diagnostic(range, msg, severity);
+    d.source = 'rblua'; return d;
+}
+
+// ─── Formatter ───────────────────────────────────────────────────────────────
+
+function format(doc) {
+    const text = doc.getText(), formatted = formatText(text);
+    if (formatted === text) return [];
+    return [vscode.TextEdit.replace(
+        new vscode.Range(doc.positionAt(0), doc.positionAt(text.length)), formatted)];
+}
+
+// init / on / func blocks contain Lua code; ui / page / groupbox blocks contain DSL.
+function isLuaBlockOpener(clean) {
+    return /\binit\s*\{/.test(clean)
+        || /\bfunc\s+\w/.test(clean)
+        || /\bon\s+\w/.test(clean);
+}
+
+// ── Lua keyword indentation helpers ──────────────────────────────────────────
+
+// How much to de-indent BEFORE emitting this Lua line.
+function luaPreDecrement(s, leadClose) {
+    if (/^end\b/.test(s))    return 1;
+    if (/^else\b/.test(s))   return 1;
+    if (/^elseif\b/.test(s)) return 1;
+    if (/^until\b/.test(s))  return 1;
+    if (leadClose)            return 1;  // leading }
+    return 0;
+}
+
+// Net depth change AFTER emitting this Lua line.
+// preDecrement tells us which closing keywords were already handled.
+function luaPostNet(clean, opens, closes, pre) {
+    const s = clean.trimStart();
+
+    let openCount = (clean.match(/\bthen\b/g)     || []).length
+                  + (clean.match(/\bdo\b/g)        || []).length
+                  + (clean.match(/\brepeat\b/g)    || []).length
+                  + (clean.match(/\bfunction\b/g)  || []).length
+                  + opens;
+
+    // 'else' implicitly opens the next block (no explicit keyword like 'then')
+    if (/^else\b/.test(s) && !/^elseif\b/.test(s)) openCount += 1;
+
+    let closeCount = (clean.match(/\bend\b/g)   || []).length
+                   + (clean.match(/\buntil\b/g) || []).length
+                   + closes;
+
+    // Subtract already-handled pre-decrements so we don't double-count
+    if (/^end\b/.test(s))              closeCount -= 1;
+    if (/^until\b/.test(s))            closeCount -= 1;
+    if (clean.trimStart().startsWith('}')) closeCount -= 1;
+
+    return openCount - closeCount;
+}
+
+// ── Main formatter ────────────────────────────────────────────────────────────
+
+function formatText(text) {
+    const TAB  = '    ';
+    const lines = text.split('\n');
+    const out   = [];
+    let depth = 0, lastBlank = false;
+
+    // luaDepth > 0: we're inside a Lua code block.
+    // luaFloor: minimum depth allowed inside this Lua block (= content base depth).
+    let luaDepth = 0, luaFloor = 0;
+
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line) {
+            if (!lastBlank && out.length > 0) out.push('');
+            lastBlank = true; continue;
+        }
+        lastBlank = false;
+
+        const clean     = stripLineForCount(line);
+        const opens     = (clean.match(/\{/g) || []).length;
+        const closes    = (clean.match(/\}/g) || []).length;
+        const leadClose = clean.trimStart().startsWith('}');
+
+        if (luaDepth > 0) {
+            const net = opens - closes;
+
+            if (leadClose && luaDepth + net <= 0) {
+                // This } is the Lua block's closing brace — back to DSL mode
+                luaDepth = 0;
+                depth    = Math.max(0, depth - 1);
+                out.push(TAB.repeat(depth) + line);
+                const afterNet = opens - (closes - 1);
+                if (afterNet > 0) depth += afterNet;
+            } else {
+                // Lua code — apply Lua-aware keyword indentation
+                const pre = luaPreDecrement(clean.trimStart(), leadClose);
+                depth     = Math.max(luaFloor, depth - pre);
+                out.push(TAB.repeat(depth) + line);
+                depth     = Math.max(luaFloor, depth + luaPostNet(clean, opens, closes, pre));
+                luaDepth += net;
+            }
+            continue;
+        }
+
+        // ── DSL mode ─────────────────────────────────────────────────────────
+        if (leadClose) depth = Math.max(0, depth - 1);
+        out.push(TAB.repeat(depth) + line);
+
+        if (opens > 0) {
+            const netAfter = leadClose ? opens - (closes - 1) : opens - closes;
+            if (isLuaBlockOpener(clean)) {
+                luaFloor = depth + netAfter;
+                luaDepth = netAfter;
+            }
+            depth = Math.max(0, depth + netAfter);
+        } else if (!leadClose && closes > 0) {
+            depth = Math.max(0, depth - closes);
+        }
+    }
+
+    while (out.length && !out[out.length - 1]) out.pop();
+    return out.join('\n') + '\n';
+}
+
+function stripLineForCount(line) {
+    let r = '', i = 0;
+    while (i < line.length) {
+        if (line[i] === '-' && line[i + 1] === '-') break;
+        if (line[i] === '"' || line[i] === "'") {
+            const q = line[i++];
+            while (i < line.length && line[i] !== q) { if (line[i] === '\\') i++; i++; }
+            i++; continue;
+        }
+        r += line[i++];
+    }
+    return r;
+}
+
+function blankStringsAndComments(text) {
+    let r = '', i = 0;
+    while (i < text.length) {
+        if (text[i] === '-' && text[i + 1] === '-') {
+            if (text[i + 2] === '[' && text[i + 3] === '[') {
+                const end = text.indexOf(']]', i + 4), len = end < 0 ? text.length - i : end + 2 - i;
+                r += ' '.repeat(len); i += len;
+            } else {
+                const nl = text.indexOf('\n', i), len = nl < 0 ? text.length - i : nl - i;
+                r += ' '.repeat(len); i += len;
+            }
+            continue;
+        }
+        if (text[i] === '[' && text[i + 1] === '[') {
+            const end = text.indexOf(']]', i + 2), len = end < 0 ? text.length - i : end + 2 - i;
+            r += ' '.repeat(len); i += len; continue;
+        }
+        if (text[i] === '"' || text[i] === "'") {
+            const q = text[i++]; r += ' ';
+            while (i < text.length && text[i] !== q && text[i] !== '\n') {
+                if (text[i] === '\\') { i++; r += ' '; } r += ' '; i++;
+            }
+            r += ' '; i++; continue;
+        }
+        r += text[i++];
+    }
+    return r;
+}
+
+// ─── Autocomplete ─────────────────────────────────────────────────────────────
+
+const LUA_KEYWORDS = [
+    'local', 'if', 'then', 'else', 'elseif', 'end', 'for', 'while', 'do',
+    'repeat', 'until', 'return', 'break', 'in', 'function', 'not', 'and', 'or',
+    'true', 'false', 'nil',
+];
+
+const DSL_SNIPPETS = [
+    { label: 'component', detail: 'Pulse component skeleton', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString(
+`component {
+    signal \${1:name} = \${2:false}
+
+    init {
+        \$0
+    }
+
+    on \${1:name} {
+        func.\${3:Handler}(v)
+    }
+
+    ui {
+        toggle "\${4:Label}" -> \${1:name}
+    }
+}`) },
+    { label: 'page', detail: 'Page DSL skeleton', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString(
+`page "\${1:Name}" {
+    groupbox \${2|left,right|} "\${3:Title}" {
+        \$0
+    }
+}`) },
+    { label: 'signal', detail: 'signal name = default', kind: vscode.CompletionItemKind.Keyword,
+      insert: new vscode.SnippetString('signal \${1:name} = \${2:false}') },
+    { label: 'init', detail: 'Initialisation block', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('init {\n    $0\n}') },
+    { label: 'on', detail: 'Signal or event handler', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('on \${1:signal} {\n    $0\n}') },
+    { label: 'func', detail: 'Component method', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('func \${1:Name}() {\n    $0\n}') },
+    { label: 'ui', detail: 'UI widget block', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('ui {\n    $0\n}') },
+    { label: 'groupbox', detail: 'groupbox left|right "Title" { }', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('groupbox \${1|left,right|} "\${2:Title}" {\n    $0\n}') },
+    { label: 'toggle', detail: 'toggle "Label" -> signal', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('toggle "\${1:Label}" -> \${2:Component}.\${3:signal}') },
+    { label: 'slider', detail: 'slider "Label" -> signal [min, max]', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('slider "\${1:Label}" -> \${2:Component}.\${3:signal} [\${4:0}, \${5:100}]') },
+    { label: 'dropdown', detail: 'dropdown "Label" -> signal ["A","B"]', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('dropdown "\${1:Label}" -> \${2:Component}.\${3:signal} ["\${4:A}", "\${5:B}"]') },
+    { label: 'button', detail: 'button "Label" -> Component:Method()', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('button "\${1:Label}" -> \${2:Component}:\${3:Method}()') },
+    { label: 'keybind', detail: 'keybind "Label" key="K" -> Component:Method()', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('keybind "\${1:Label}" key="\${2:K}" -> \${3:Component}:\${4:Method}()') },
+    { label: 'mount', detail: 'mount ComponentName', kind: vscode.CompletionItemKind.Keyword,
+      insert: new vscode.SnippetString('mount \${1:Component}') },
+    { label: 'separator', detail: 'Visual separator', kind: vscode.CompletionItemKind.Keyword,
+      insert: 'separator' },
+    { label: 'label', detail: 'label "text"', kind: vscode.CompletionItemKind.Snippet,
+      insert: new vscode.SnippetString('label "\${1:text}"') },
+    { label: 'when', detail: 'Conditional modifier  (on Event when signal)', kind: vscode.CompletionItemKind.Keyword,
+      insert: new vscode.SnippetString('when \${1:signal}') },
+];
+
+function completions(doc, pos) {
+    const prefix = doc.lineAt(pos.line).text.slice(0, pos.character).trimStart();
+    const items  = [];
+
+    if (/^on\s+\w*$/.test(prefix)) {
+        for (const sig of parseSignals(doc.getText())) {
+            const item = new vscode.CompletionItem(sig, vscode.CompletionItemKind.Variable);
+            item.detail = 'signal'; item.sortText = '0' + sig; items.push(item);
+        }
+        for (const ev of KNOWN_EVENTS) {
+            const item = new vscode.CompletionItem(ev, vscode.CompletionItemKind.Event);
+            item.detail = 'event'; item.sortText = '1' + ev; items.push(item);
+        }
+    }
+
+    if (/^mount\s+\w*$/.test(prefix)) {
+        for (const comp of parseComponents(doc.getText())) {
+            const item = new vscode.CompletionItem(comp, vscode.CompletionItemKind.Class);
+            item.detail = 'component'; item.sortText = '0' + comp; items.push(item);
+        }
+    }
+
+    for (const s of DSL_SNIPPETS) {
+        const item = new vscode.CompletionItem(s.label, s.kind);
+        item.detail = s.detail; item.insertText = s.insert; item.sortText = '5' + s.label;
+        items.push(item);
+    }
+    for (const kw of LUA_KEYWORDS) {
+        const item = new vscode.CompletionItem(kw, vscode.CompletionItemKind.Keyword);
+        item.sortText = '9' + kw; items.push(item);
+    }
+    return items;
+}
+
+function parseSignals(text) {
+    const s = new Set();
+    for (const line of text.split('\n')) {
+        const m = line.trim().match(/^signal\s+(\w+)\s*=/);
+        if (m) s.add(m[1]);
+    }
+    return [...s];
+}
+
+function parseComponents(text) {
+    const s = new Set();
+    for (const m of text.matchAll(/\b([A-Z][a-zA-Z0-9_]*)\b/g)) s.add(m[1]);
+    return [...s];
+}

package/vscode/syntaxes/rblua.tmLanguage.json

@@ -0,0 +1,126 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "rblua",
+  "scopeName": "source.rblua",
+  "patterns": [
+    { "include": "#block-comment" },
+    { "include": "#line-comment" },
+    { "include": "#long-string" },
+    { "include": "#double-string" },
+    { "include": "#single-string" },
+    { "include": "#number" },
+    { "include": "#signal-decl" },
+    { "include": "#on-handler" },
+    { "include": "#func-decl" },
+    { "include": "#pulse-keywords" },
+    { "include": "#page-dsl" },
+    { "include": "#widget-types" },
+    { "include": "#lua-control" },
+    { "include": "#lua-storage" },
+    { "include": "#lua-constants" },
+    { "include": "#lua-operators" },
+    { "include": "#arrow" },
+    { "include": "#attribute-name" },
+    { "include": "#type-ref" }
+  ],
+  "repository": {
+    "block-comment": {
+      "name": "comment.block.rblua",
+      "begin": "--\\[\\[",
+      "end": "\\]\\]",
+      "beginCaptures": { "0": { "name": "punctuation.definition.comment.rblua" } },
+      "endCaptures":   { "0": { "name": "punctuation.definition.comment.rblua" } }
+    },
+    "line-comment": {
+      "name": "comment.line.double-dash.rblua",
+      "match": "--.*$"
+    },
+    "long-string": {
+      "name": "string.quoted.other.rblua",
+      "begin": "\\[\\[",
+      "end": "\\]\\]"
+    },
+    "double-string": {
+      "name": "string.quoted.double.rblua",
+      "begin": "\"",
+      "end": "\"",
+      "patterns": [{ "name": "constant.character.escape.rblua", "match": "\\\\." }]
+    },
+    "single-string": {
+      "name": "string.quoted.single.rblua",
+      "begin": "'",
+      "end": "'",
+      "patterns": [{ "name": "constant.character.escape.rblua", "match": "\\\\." }]
+    },
+    "number": {
+      "name": "constant.numeric.rblua",
+      "match": "\\b(0[xX][0-9a-fA-F]+|\\d+\\.\\d+(?:[eE][+-]?\\d+)?|\\d+(?:[eE][+-]?\\d+)?)\\b"
+    },
+    "signal-decl": {
+      "comment": "signal name = value  →  'signal' keyword + signal name",
+      "match": "\\b(signal)\\s+([a-z_][a-zA-Z0-9_]*)\\b",
+      "captures": {
+        "1": { "name": "storage.type.component.rblua" },
+        "2": { "name": "variable.other.readwrite.rblua" }
+      }
+    },
+    "on-handler": {
+      "comment": "on name [(params)] [when x] {  →  'on' keyword + handler/signal name",
+      "match": "\\b(on)\\s+([A-Za-z_][a-zA-Z0-9_]*)\\b",
+      "captures": {
+        "1": { "name": "storage.type.component.rblua" },
+        "2": { "name": "entity.name.tag.rblua" }
+      }
+    },
+    "func-decl": {
+      "comment": "func MethodName([params]) {  →  'func' keyword + method name",
+      "match": "\\b(func)\\s+([A-Za-z_][a-zA-Z0-9_]*)\\s*\\([^)]*\\)",
+      "captures": {
+        "1": { "name": "storage.type.component.rblua" },
+        "2": { "name": "entity.name.function.rblua" }
+      }
+    },
+    "pulse-keywords": {
+      "name": "storage.type.component.rblua",
+      "match": "\\b(component|signal|init|on|func|ui)\\b"
+    },
+    "page-dsl": {
+      "name": "keyword.control.page.rblua",
+      "match": "\\b(page|groupbox|mount|separator|left|right|when|every|debounce)\\b"
+    },
+    "widget-types": {
+      "name": "support.type.widget.rblua",
+      "match": "\\b(toggle|slider|dropdown|button|keybind|label)\\b"
+    },
+    "lua-control": {
+      "name": "keyword.control.lua",
+      "match": "\\b(if|then|else|elseif|end|for|while|do|repeat|until|return|break|in)\\b"
+    },
+    "lua-storage": {
+      "name": "storage.type.lua",
+      "match": "\\b(local|function)\\b"
+    },
+    "lua-constants": {
+      "name": "constant.language.lua",
+      "match": "\\b(true|false|nil)\\b"
+    },
+    "lua-operators": {
+      "name": "keyword.operator.lua",
+      "match": "\\b(not|and|or)\\b"
+    },
+    "arrow": {
+      "name": "keyword.operator.arrow.rblua",
+      "match": "->"
+    },
+    "attribute-name": {
+      "comment": "key= tip= min= max=  in widget lines",
+      "name": "entity.other.attribute-name.rblua",
+      "match": "\\b(key|tip|min|max)(?=\\s*=)"
+    },
+    "type-ref": {
+      "comment": "PascalCase identifiers → component references",
+      "name": "entity.name.type.rblua",
+      "match": "\\b[A-Z][a-zA-Z0-9_]*\\b"
+    }
+  }
+}