@zubra/language-server 5.4.0 → 5.5.0

package/backend.js

@@ -55,9 +55,52 @@ function wasmBackend(wasm) {
       const response = wasm.request({ command: 'format', path: absolute, files: { [absolute]: text }, ...options });
       return response.ok ? { ok: true, output: response.output } : { ok: false, error: response.error ?? '' };
     },
+    formatRange(path, text, range, options) {
+      const absolute = resolve(path);
+      const response = wasm.request({ command: 'formatRange', path: absolute, files: { [absolute]: text }, ...range, ...options });
+      return rangeEdit(response?.ok ? { ok: true, output: response.output } : { ok: false, error: response?.error ?? '' });
+    },
+    refactor(path, text, extraction) {
+      const absolute = resolve(path);
+      const files = wasm.sources(absolute);
+      files[absolute] = text;
+      for (const specifier of importsOf(text)) wasm.sources(resolve(dirname(absolute), specifier), files);
+      return refactored(wasm.request({ command: 'refactor', action: 'extract', path: absolute, files, ...extraction }));
+    },
   };
 }
 
+/**
+ * A `formatRange` answer as { ok, edit } (edit: null when nothing changes) or { ok: false, error,
+ * unsupported? }. A compiler from before the command compiles the file instead: its answer isn't
+ * the command's.
+ */
+function rangeEdit(answer) {
+  if (!answer.ok) return { ok: false, error: answer.error, unsupported: /unknown command|usage: zubra/.test(answer.error) };
+  try {
+    const parsed = JSON.parse(answer.output);
+    if (parsed && typeof parsed === 'object' && 'edit' in parsed) return { ok: true, edit: parsed.edit };
+  } catch {
+    // Not the command's answer.
+  }
+  return { ok: false, error: 'this compiler does not know range formatting', unsupported: true };
+}
+
+/** A `refactor` response as { ok, result } or { ok: false, reason, unsupported? }. */
+function refactored(response) {
+  if (response?.ok) {
+    // A compiler from before the command doesn't know it and compiles the file instead.
+    try {
+      const result = JSON.parse(response.output);
+      if (typeof result?.fileSource === 'string' && Array.isArray(result.edits)) return { ok: true, result };
+    } catch {
+      // Not the command's answer.
+    }
+    return { ok: false, unsupported: true, reason: 'this compiler does not know the refactor command' };
+  }
+  return { ok: false, reason: response?.diagnostics?.[0]?.message ?? response?.error ?? 'the compiler did not answer' };
+}
+
 function cliBackend(compiler) {
   const run = (args, input) => spawnSync(compiler, args, { encoding: 'utf8', input });
   return {
@@ -81,6 +124,30 @@ function cliBackend(compiler) {
       if (result.error) return { ok: false, error: result.error.message };
       return result.status === 0 ? { ok: true, output: result.stdout } : { ok: false, error: result.stderr };
     },
+    formatRange(path, text, range, { indentWidth, useTabs, printWidth } = {}) {
+      const absolute = resolve(path);
+      const request = { command: 'formatRange', path: absolute, files: { [absolute]: text }, ...range, indentWidth, useTabs, printWidth };
+      const result = run(['request'], JSON.stringify(request));
+      if (result.error) return { ok: false, error: result.error.message };
+      try {
+        const response = JSON.parse(result.stdout);
+        return rangeEdit(response.ok ? { ok: true, output: response.output } : { ok: false, error: response.error ?? '' });
+      } catch {
+        return { ok: false, error: result.stderr, unsupported: true };
+      }
+    },
+    refactor(path, text, extraction) {
+      const absolute = resolve(path);
+      const files = { [absolute]: text };
+      for (const specifier of importsOf(text)) {
+        const imported = resolve(dirname(absolute), specifier);
+        const source = readText(imported);
+        if (source !== null) files[imported] = source;
+      }
+      const result = run(['request'], JSON.stringify({ command: 'refactor', action: 'extract', path: absolute, files, ...extraction }));
+      if (result.error) return { ok: false, reason: result.error.message };
+      try { return refactored(JSON.parse(result.stdout)); } catch { return { ok: false, reason: result.stderr || 'the compiler did not answer', unsupported: true }; }
+    },
   };
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zubra/language-server",
-  "version": "5.4.0",
+  "version": "5.5.0",
   "description": "Language server for .zb components: diagnostics, completion, hover and go to definition",
   "license": "ISC",
   "repository": {

package/server.js

@@ -1,31 +1,44 @@
 #!/usr/bin/env node
 // zubra language server: diagnostics from the compiler as you type, completion of directives,
 // imported components, their props and events, hover documentation from their manifests, and
-// go to definition for imported components, and formatting (`zubra fmt`). Speaks LSP over stdio
+// go to definition for imported components, formatting (`zubra fmt`), and the Extract to component
+// refactor (a code action, and the `zubra.applyExtractComponent` command that takes a name). Speaks LSP over stdio
 // (`--stdio`).
 //
 // initializationOptions: { compiler?: "/path/to/zubra", printWidth?: number } — otherwise
 // @zubra/compiler (WebAssembly) when installed, else `zubra` on PATH. printWidth is the width a
 // tag is fitted into when formatting (default 100); indentation comes from the editor.
-import { createConnection, ProposedFeatures, TextDocuments, TextDocumentSyncKind, DiagnosticSeverity, CompletionItemKind, InsertTextFormat, MarkupKind } from 'vscode-languageserver/node';
+import { createConnection, ProposedFeatures, TextDocuments, TextDocumentSyncKind, DiagnosticSeverity, CompletionItemKind, InsertTextFormat, MarkupKind, CodeActionKind } from 'vscode-languageserver/node';
 import { TextDocument } from 'vscode-languageserver-textdocument';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, resolve } from 'node:path';
-import { statSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { createBackend, importsOf, readText } from './backend.js';
-import { completions, documentation, interfaceOf, offsetAt, positionAt, tagAt } from './analysis.js';
+import { completions, documentation, hostOf, interfaceOf, offsetAt, positionAt, tagAt } from './analysis.js';
 
+const EXTRACT_COMMAND = 'zubra.applyExtractComponent'; // not the editor command's name: the client registers the server's commands itself
 const connection = createConnection(ProposedFeatures.all);
 const documents = new TextDocuments(TextDocument);
 let backend;
 let printWidth;
 let toldAboutVersion = false;
+let toldAboutRangeVersion = false;
 const manifests = new Map(); // path → { mtime, component }
 
+// What the editor said it can do, for Extract to component: the edit creates a file, which not
+// every client applies, and a client that doesn't know disabled actions would show one as usable.
+const client = { createsFiles: false, appliesEdits: false, actionLiterals: false, disabledActions: false };
+
 connection.onInitialize(async (params) => {
   const folder = params.workspaceFolders?.[0]?.uri ?? params.rootUri;
   backend = await createBackend({ ...params.initializationOptions, root: folder ? fileURLToPath(folder) : undefined });
   printWidth = Number(params.initializationOptions?.printWidth) || undefined;
+  const edits = params.capabilities?.workspace?.workspaceEdit;
+  const actions = params.capabilities?.textDocument?.codeAction;
+  client.createsFiles = edits?.documentChanges === true && (edits.resourceOperations ?? []).includes('create');
+  client.appliesEdits = params.capabilities?.workspace?.applyEdit === true;
+  client.actionLiterals = !!actions?.codeActionLiteralSupport;
+  client.disabledActions = actions?.disabledSupport === true;
   return {
     capabilities: {
       textDocumentSync: TextDocumentSyncKind.Incremental,
@@ -33,6 +46,10 @@ connection.onInitialize(async (params) => {
       hoverProvider: true,
       definitionProvider: true,
       documentFormattingProvider: true,
+      documentRangeFormattingProvider: true,
+      // Only to an editor that can take the edit: a new file and changes to this one, together.
+      ...(client.createsFiles && client.actionLiterals ? { codeActionProvider: { codeActionKinds: [CodeActionKind.RefactorExtract] } } : {}),
+      ...(client.createsFiles && client.appliesEdits ? { executeCommandProvider: { commands: [EXTRACT_COMMAND] } } : {}),
     },
     serverInfo: { name: 'zubra-language-server', version: '1.2.0' },
   };
@@ -40,6 +57,10 @@ connection.onInitialize(async (params) => {
 
 const pathOf = (uri) => fileURLToPath(uri);
 
+// Byte offsets (the compiler's) and string indexes (LSP's UTF-16 positions).
+const byteOffset = (text, index) => Buffer.byteLength(text.slice(0, index));
+const indexOfByte = (text, bytes) => Buffer.from(text).subarray(0, bytes).toString().length;
+
 /** The components a document imports: { tag, …interface, path }. */
 function componentsOf(uri, text) {
   const base = dirname(pathOf(uri));
@@ -148,5 +169,110 @@ connection.onDocumentFormatting(({ textDocument, options }) => {
   return [{ range: { start: { line: 0, character: 0 }, end: positionAt(text, text.length) }, newText: result.output }];
 });
 
+// Format Selection (and format on paste): the lines the selection touches, as `zubra fmt` would
+// write them in the whole file. One edit, or none when they're already formatted.
+connection.onDocumentRangeFormatting(({ textDocument, range, options }) => {
+  const document = documents.get(textDocument.uri);
+  if (!document) return [];
+  const text = document.getText();
+  const answer = backend.formatRange?.(
+    pathOf(textDocument.uri),
+    text,
+    { start: byteOffset(text, offsetAt(text, range.start)), end: byteOffset(text, offsetAt(text, range.end)) },
+    { indentWidth: options.tabSize, useTabs: options.insertSpaces === false, printWidth },
+  );
+  if (!answer?.ok) {
+    if (answer?.unsupported && !toldAboutRangeVersion) {
+      toldAboutRangeVersion = true;
+      connection.window.showInformationMessage('Formatting a selection needs a newer Zubra: update @zubra/compiler (or the zubra CLI).');
+    }
+    return [];
+  }
+  if (!answer.edit) return [];
+  return [{
+    range: { start: positionAt(text, indexOfByte(text, answer.edit.start)), end: positionAt(text, indexOfByte(text, answer.edit.end)) },
+    newText: answer.edit.text,
+  }];
+});
+
+// ---- Extract to component -------------------------------------------------------------------
+// The compiler (`refactor`, `action: "extract"`) decides what can be extracted and how; offsets
+// there are UTF-8 bytes, LSP's are UTF-16 (`byteOffset` and `indexOfByte`, above).
+
+/** A name for the new component that isn't taken beside the document. */
+function defaultTag(uri, text) {
+  const base = `${hostOf(text)?.tag ?? 'my'}-part`;
+  const directory = dirname(pathOf(uri));
+  let tag = base;
+  for (let n = 2; existsSync(resolve(directory, `${tag}.zb`)); n++) tag = `${base}-${n}`;
+  return tag;
+}
+
+/** The workspace edit for extracting `range` of the document as `tag`, or why it can't be. */
+function extraction(document, range, tag) {
+  const text = document.getText();
+  const start = byteOffset(text, offsetAt(text, range.start));
+  const end = byteOffset(text, offsetAt(text, range.end));
+  const made = backend.refactor?.(pathOf(document.uri), text, { start, end, tag });
+  if (!made) return { reason: 'This compiler cannot extract components: update @zubra/compiler (or the zubra CLI).' };
+  if (!made.ok) {
+    return { reason: made.unsupported ? 'Extracting a component needs a newer Zubra: update @zubra/compiler (or the zubra CLI).' : made.reason };
+  }
+  const { fileName, fileSource, edits } = made.result;
+  const newPath = resolve(dirname(pathOf(document.uri)), fileName);
+  // The edit creates the file and would fail on one that's there, after the name was chosen.
+  if (existsSync(newPath)) return { reason: `${fileName} already exists beside this file: choose another name.` };
+  const newUri = pathToFileURL(newPath).href;
+  return {
+    edit: {
+      documentChanges: [
+        { kind: 'create', uri: newUri, options: { ignoreIfExists: false } },
+        { textDocument: { uri: newUri, version: null }, edits: [{ range: { start: { line: 0, character: 0 }, end: { line: 0, character: 0 } }, newText: fileSource }] },
+        {
+          textDocument: { uri: document.uri, version: document.version },
+          edits: edits.map((edit) => ({
+            range: { start: positionAt(text, indexOfByte(text, edit.start)), end: positionAt(text, indexOfByte(text, edit.end)) },
+            newText: edit.text,
+          })),
+        },
+      ],
+    },
+    tag: made.result.tag,
+  };
+}
+
+// The code action: offered on a non-empty selection, with a default name; when the compiler
+// refuses, it's shown disabled with the reason, so the rule is discoverable.
+connection.onCodeAction(({ textDocument, range, context }) => {
+  const document = documents.get(textDocument.uri);
+  if (!document || !client.createsFiles || !client.actionLiterals) return [];
+  if (context.only && !context.only.some((kind) => CodeActionKind.RefactorExtract.startsWith(kind))) return [];
+  if (range.start.line === range.end.line && range.start.character === range.end.character) return [];
+  const made = extraction(document, range, defaultTag(textDocument.uri, document.getText()));
+  if (!made.edit) {
+    // An editor that doesn't know `disabled` would offer this as an action that does nothing.
+    if (!client.disabledActions) return [];
+    return [{ title: 'Extract to component', kind: CodeActionKind.RefactorExtract, disabled: { reason: made.reason } }];
+  }
+  return [{ title: `Extract to component <${made.tag}>`, kind: CodeActionKind.RefactorExtract, edit: made.edit }];
+});
+
+// For editors that ask for the name first (the VS Code extension): [uri, range, tag].
+connection.onExecuteCommand(async ({ command, arguments: args }) => {
+  if (command !== EXTRACT_COMMAND) return null;
+  const [uri, range, tag] = args ?? [];
+  const document = documents.get(uri);
+  if (!document || !range || !tag) return { error: 'Extract to component needs a document, a selection and a name.' };
+  if (!client.createsFiles || !client.appliesEdits) return { error: 'This editor did not say it can apply an edit that creates a file, which extracting a component needs.' };
+  const made = extraction(document, range, tag);
+  if (!made.edit) {
+    connection.window.showErrorMessage(made.reason);
+    return { error: made.reason };
+  }
+  const applied = await connection.workspace.applyEdit(made.edit);
+  if (!applied.applied) connection.window.showErrorMessage(`Couldn't extract: ${applied.failureReason ?? 'the editor refused the edit'}`);
+  return { applied: applied.applied, tag: made.tag };
+});
+
 documents.listen(connection);
 connection.listen();