@tsuzuri-lab/sed-language-server 0.2.0 → 0.3.0

package/README.md

@@ -22,6 +22,7 @@ sed-language-server --stdio
 
 - Tree-sitter-based diagnostics
 - go to definition from `b`, `t`, and GNU `T` label references
+- document formatting for command lists and nested blocks
 
 Scripts are analyzed without executing them or accessing referenced files.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsuzuri-lab/sed-language-server",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Language server for POSIX sed with opt-in GNU syntax support.",
   "keywords": [
     "sed",

package/src/definition.js

@@ -0,0 +1,44 @@
+import { rangeForNode, syntaxTreeFor } from "./syntax.js";
+
+function collectLabels(rootNode, offset) {
+  const definitions = [];
+  let reference;
+  const stack = [rootNode];
+
+  while (stack.length > 0) {
+    const node = stack.pop();
+    if (node.type === "label_definition") {
+      definitions.push(node);
+    } else if (
+      node.type === "label_reference" &&
+      node.startIndex <= offset &&
+      offset < node.endIndex
+    ) {
+      reference = node;
+    }
+    stack.push(...node.children.toReversed());
+  }
+
+  return { definitions, reference };
+}
+
+export function createDefinitionLocations(document, position, dialect) {
+  const tree = syntaxTreeFor(document, dialect);
+  const { definitions, reference } = collectLabels(
+    tree.rootNode,
+    document.offsetAt(position),
+  );
+
+  if (reference === undefined) {
+    return null;
+  }
+
+  const locations = definitions
+    .filter((definition) => definition.text === reference.text)
+    .map((definition) => ({
+      uri: document.uri,
+      range: rangeForNode(document, definition),
+    }));
+
+  return locations.length === 0 ? null : locations;
+}

package/src/diagnostics.js

@@ -0,0 +1,119 @@
+import { DiagnosticSeverity } from "vscode-languageserver/node";
+import {
+  collectSyntaxIssueNodes,
+  rangeForNode,
+  syntaxTreeFor,
+} from "./syntax.js";
+
+const diagnosticSource = "sed-language-server";
+
+const issueDescriptions = {
+  incomplete_escape: {
+    code: "incomplete-escape",
+    message: "This escape sequence is incomplete.",
+  },
+  incomplete_regex: {
+    code: "unterminated-regular-expression",
+    message: "This regular expression is not terminated.",
+  },
+  incomplete_replacement: {
+    code: "unterminated-replacement",
+    message: "This replacement is not terminated.",
+  },
+  incomplete_translate: {
+    code: "unterminated-translation",
+    message: "This translation is not terminated.",
+  },
+  invalid_control_escape: {
+    code: "invalid-control-escape",
+    message: "This GNU sed control escape is invalid.",
+  },
+  unclosed_bracket: {
+    code: "unclosed-bracket-expression",
+    message: "This bracket expression is not terminated.",
+  },
+  invalid_command: (node, dialect) => ({
+    code: "invalid-command",
+    message: `Unknown ${dialectName(dialect)} sed command: \`${node.text}\`.`,
+  }),
+  invalid_flag: (node, dialect) => ({
+    code: "invalid-substitution-flag",
+    message: `Unknown ${dialectName(dialect)} sed substitution flag: \`${node.text}\`.`,
+  }),
+  unexpected_text: (_node, dialect) => ({
+    code: "unexpected-text",
+    message: `Unexpected text after this ${dialectName(dialect)} sed command.`,
+  }),
+};
+
+function dialectName(dialect) {
+  return dialect === "gnu" ? "GNU" : "POSIX";
+}
+
+function descriptionFor(node, dialect) {
+  const description = issueDescriptions[node.type];
+  if (typeof description === "function") {
+    return description(node, dialect);
+  }
+  if (description !== undefined) {
+    return description;
+  }
+
+  if (node.isMissing) {
+    return {
+      code: "missing-syntax",
+      message: `Expected ${node.type.replaceAll("_", " ")}.`,
+    };
+  }
+
+  return {
+    code: "syntax-error",
+    message: `Invalid ${dialectName(dialect)} sed syntax.`,
+  };
+}
+function issuePriority(node) {
+  if (node.isError) {
+    return 0;
+  }
+  if (node.isMissing) {
+    return 1;
+  }
+  return 2;
+}
+
+function preferSpecificIssues(nodes) {
+  const issuesByRange = new Map();
+
+  for (const node of nodes) {
+    const key = `${node.startIndex}:${node.endIndex}`;
+    const existing = issuesByRange.get(key);
+    if (
+      existing === undefined ||
+      issuePriority(node) > issuePriority(existing)
+    ) {
+      issuesByRange.set(key, node);
+    }
+  }
+
+  return [...issuesByRange.values()].sort(
+    (left, right) =>
+      left.startIndex - right.startIndex || left.endIndex - right.endIndex,
+  );
+}
+
+export function createDiagnostics(document, dialect) {
+  const tree = syntaxTreeFor(document, dialect);
+
+  return preferSpecificIssues(collectSyntaxIssueNodes(tree.rootNode)).map(
+    (node) => {
+      const { code, message } = descriptionFor(node, dialect);
+      return {
+        severity: DiagnosticSeverity.Error,
+        range: rangeForNode(document, node),
+        message,
+        code,
+        source: diagnosticSource,
+      };
+    },
+  );
+}

package/src/formatting.js

@@ -0,0 +1,97 @@
+import { collectSyntaxIssueNodes, syntaxTreeFor } from "./syntax.js";
+
+function formatCommandList(node, indentation, lineEnding, depth) {
+  return node.children
+    .filter((child) => child.type === "command")
+    .map((command) => formatCommand(command, indentation, lineEnding, depth))
+    .join(lineEnding);
+}
+
+function formatCommand(command, indentation, lineEnding, depth) {
+  const prefix = indentation.repeat(depth);
+  const body = command.childForFieldName("body");
+  if (body.type !== "block_command") {
+    return `${prefix}${command.text}`;
+  }
+
+  const openingBrace = body.childForFieldName("name");
+  const opening = command.text.slice(
+    0,
+    openingBrace.endIndex - command.startIndex,
+  );
+  const commandList = body.childForFieldName("argument");
+  if (commandList === null) {
+    return `${prefix}${opening}}`;
+  }
+
+  const formattedCommands = formatCommandList(
+    commandList,
+    indentation,
+    lineEnding,
+    depth + 1,
+  );
+  const content =
+    formattedCommands === "" ? "" : `${formattedCommands}${lineEnding}`;
+
+  return `${prefix}${opening}${lineEnding}${content}${prefix}}`;
+}
+
+function indentationFor(options) {
+  return options.insertSpaces ? " ".repeat(options.tabSize) : "\t";
+}
+
+function formatScript(rootNode, source, options) {
+  const lineEnding = source.match(/\r\n|\n/)?.[0] ?? "\n";
+  const indentation = indentationFor(options);
+  const firstLine = rootNode.children.find(
+    (child) => child.type === "first_line_silent",
+  );
+  const commandList = rootNode.children.find(
+    (child) => child.type === "command_list",
+  );
+  const sections = [];
+
+  if (firstLine !== undefined) {
+    sections.push(firstLine.text);
+  }
+  if (commandList !== undefined) {
+    const formattedCommands = formatCommandList(
+      commandList,
+      indentation,
+      lineEnding,
+      0,
+    );
+    if (formattedCommands !== "") {
+      sections.push(formattedCommands);
+    }
+  }
+
+  let formatted = sections.join(lineEnding);
+  if (source.endsWith("\n") && !formatted.endsWith("\n")) {
+    formatted += lineEnding;
+  }
+  return formatted;
+}
+
+export function createFormattingEdits(document, dialect, options) {
+  const source = document.getText();
+  const tree = syntaxTreeFor(document, dialect);
+  if (collectSyntaxIssueNodes(tree.rootNode).length > 0) {
+    return [];
+  }
+
+  const formatted = formatScript(tree.rootNode, source, options);
+  if (formatted === source) {
+    return [];
+  }
+
+  return [
+    {
+      range: {
+        start: document.positionAt(0),
+        end: document.positionAt(source.length),
+      },
+      newText: formatted,
+    },
+  ];
+}

package/src/server.js

@@ -11,11 +11,10 @@ import {
   TextDocuments,
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import {
-  createDefinitionLocations,
-  createDiagnostics,
-  invalidateSyntaxTreeCache,
-} from "./analysis.js";
+import { createDefinitionLocations } from "./definition.js";
+import { createDiagnostics } from "./diagnostics.js";
+import { createFormattingEdits } from "./formatting.js";
+import { invalidateSyntaxTreeCache } from "./syntax.js";
 
 if (process.argv.length === 2) {
   process.argv.push("--stdio");
@@ -81,6 +80,7 @@ connection.onInitialize(({ initializationOptions }) => {
     capabilities: {
       textDocumentSync: TextDocumentSyncKind.Incremental,
       definitionProvider: true,
+      documentFormattingProvider: true,
     },
   };
 });
@@ -108,6 +108,13 @@ connection.onDefinition(({ textDocument, position }) => {
     : createDefinitionLocations(document, position, activeDialect);
 });
 
+connection.onDocumentFormatting(({ textDocument, options }) => {
+  const document = documents.get(textDocument.uri);
+  return document === undefined
+    ? []
+    : createFormattingEdits(document, activeDialect, options);
+});
+
 documents.onDidChangeContent(({ document }) => {
   publishDiagnostics(document);
 });

package/src/syntax.js

@@ -0,0 +1,124 @@
+import { fileURLToPath } from "node:url";
+import { Language, Parser } from "web-tree-sitter";
+
+await Parser.init();
+
+async function createParser(dialect) {
+  const path = fileURLToPath(
+    new URL(`../vendor/tree-sitter-sed-${dialect}.wasm`, import.meta.url),
+  );
+  return new Parser().setLanguage(await Language.load(path));
+}
+
+const parsers = {
+  posix: await createParser("posix"),
+  gnu: await createParser("gnu"),
+};
+
+const documentTrees = new Map();
+
+export function syntaxTreeFor(document, dialect) {
+  const source = document.getText();
+  let trees = documentTrees.get(document.uri);
+
+  if (trees === undefined) {
+    trees = new Map();
+    documentTrees.set(document.uri, trees);
+  }
+
+  const cached = trees.get(dialect);
+  if (
+    cached !== undefined &&
+    cached.version === document.version &&
+    cached.source === source
+  ) {
+    return cached.tree;
+  }
+
+  cached?.tree.delete();
+  const tree = parsers[dialect].parse(source);
+  if (tree === null) {
+    throw new Error(`Failed to parse ${dialect} sed source.`);
+  }
+
+  trees.set(dialect, {
+    source,
+    tree,
+    version: document.version,
+  });
+  return tree;
+}
+
+export function invalidateSyntaxTreeCache(document) {
+  const trees = documentTrees.get(document.uri);
+  if (trees !== undefined) {
+    for (const { tree } of trees.values()) {
+      tree.delete();
+    }
+    documentTrees.delete(document.uri);
+  }
+}
+
+function isSpecificSyntaxIssue(node) {
+  return (
+    node.isMissing ||
+    node.type.startsWith("incomplete_") ||
+    node.type.startsWith("invalid_") ||
+    node.type === "unclosed_bracket" ||
+    node.type === "unexpected_text"
+  );
+}
+
+export function collectSyntaxIssueNodes(rootNode) {
+  const issues = [];
+  const stack = [
+    {
+      node: rootNode,
+      children: rootNode.children,
+      childIndex: 0,
+      hasDescendantIssue: false,
+      issueStartIndex: 0,
+    },
+  ];
+
+  while (stack.length > 0) {
+    const frame = stack.at(-1);
+    if (frame.childIndex < frame.children.length) {
+      const child = frame.children[frame.childIndex];
+      frame.childIndex += 1;
+      stack.push({
+        node: child,
+        children: child.children,
+        childIndex: 0,
+        hasDescendantIssue: false,
+        issueStartIndex: issues.length,
+      });
+      continue;
+    }
+
+    const specific = isSpecificSyntaxIssue(frame.node);
+    const selected =
+      specific || (frame.node.isError && !frame.hasDescendantIssue);
+    if (specific) {
+      issues.length = frame.issueStartIndex;
+    }
+    if (selected) {
+      issues.push(frame.node);
+    }
+
+    stack.pop();
+    const parent = stack.at(-1);
+    if (parent !== undefined) {
+      parent.hasDescendantIssue ||= frame.hasDescendantIssue || selected;
+    }
+  }
+
+  return issues;
+}
+
+export function rangeForNode(document, node) {
+  return {
+    start: document.positionAt(node.startIndex),
+    end: document.positionAt(node.endIndex),
+  };
+}

package/src/analysis.js

@@ -1,275 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { DiagnosticSeverity } from "vscode-languageserver/node";
-import { Language, Parser } from "web-tree-sitter";
-
-await Parser.init();
-
-async function createParser(dialect) {
-  const path = fileURLToPath(
-    new URL(`../vendor/tree-sitter-sed-${dialect}.wasm`, import.meta.url),
-  );
-  return new Parser().setLanguage(await Language.load(path));
-}
-
-const parsers = {
-  posix: await createParser("posix"),
-  gnu: await createParser("gnu"),
-};
-
-const documentTrees = new Map();
-
-function parseDocument(document, dialect) {
-  const source = document.getText();
-  let trees = documentTrees.get(document.uri);
-
-  if (trees === undefined) {
-    trees = new Map();
-    documentTrees.set(document.uri, trees);
-  }
-
-  const cached = trees.get(dialect);
-  if (
-    cached !== undefined &&
-    cached.version === document.version &&
-    cached.source === source
-  ) {
-    return cached.tree;
-  }
-
-  cached?.tree.delete();
-  const tree = parsers[dialect].parse(source);
-  if (tree === null) {
-    throw new Error(`Failed to parse ${dialect} sed source.`);
-  }
-
-  trees.set(dialect, {
-    source,
-    tree,
-    version: document.version,
-  });
-  return tree;
-}
-
-export function invalidateSyntaxTreeCache(document) {
-  const trees = documentTrees.get(document.uri);
-  if (trees !== undefined) {
-    for (const { tree } of trees.values()) {
-      tree.delete();
-    }
-    documentTrees.delete(document.uri);
-  }
-}
-
-const diagnosticSource = "sed-language-server";
-
-const issueDescriptions = {
-  incomplete_escape: {
-    code: "incomplete-escape",
-    message: "This escape sequence is incomplete.",
-  },
-  incomplete_regex: {
-    code: "unterminated-regular-expression",
-    message: "This regular expression is not terminated.",
-  },
-  incomplete_replacement: {
-    code: "unterminated-replacement",
-    message: "This replacement is not terminated.",
-  },
-  incomplete_translate: {
-    code: "unterminated-translation",
-    message: "This translation is not terminated.",
-  },
-  invalid_control_escape: {
-    code: "invalid-control-escape",
-    message: "This GNU sed control escape is invalid.",
-  },
-  unclosed_bracket: {
-    code: "unclosed-bracket-expression",
-    message: "This bracket expression is not terminated.",
-  },
-  invalid_command: (node, dialect) => ({
-    code: "invalid-command",
-    message: `Unknown ${dialectName(dialect)} sed command: \`${node.text}\`.`,
-  }),
-  invalid_flag: (node, dialect) => ({
-    code: "invalid-substitution-flag",
-    message: `Unknown ${dialectName(dialect)} sed substitution flag: \`${node.text}\`.`,
-  }),
-  unexpected_text: (_node, dialect) => ({
-    code: "unexpected-text",
-    message: `Unexpected text after this ${dialectName(dialect)} sed command.`,
-  }),
-};
-
-function dialectName(dialect) {
-  return dialect === "gnu" ? "GNU" : "POSIX";
-}
-
-function descriptionFor(node, dialect) {
-  const description = issueDescriptions[node.type];
-  if (typeof description === "function") {
-    return description(node, dialect);
-  }
-  if (description !== undefined) {
-    return description;
-  }
-
-  const displayName = dialectName(dialect);
-  if (node.isMissing) {
-    return {
-      code: "missing-syntax",
-      message: `Expected ${node.type.replaceAll("_", " ")}.`,
-    };
-  }
-
-  return {
-    code: "syntax-error",
-    message: `Invalid ${displayName} sed syntax.`,
-  };
-}
-
-function isSpecificIssue(node) {
-  return node.isMissing || Object.hasOwn(issueDescriptions, node.type);
-}
-
-function collectIssueNodes(rootNode) {
-  const issues = [];
-  const stack = [
-    {
-      node: rootNode,
-      children: rootNode.children,
-      childIndex: 0,
-      hasDescendantIssue: false,
-      issueStartIndex: 0,
-    },
-  ];
-
-  while (stack.length > 0) {
-    const frame = stack.at(-1);
-    if (frame.childIndex < frame.children.length) {
-      const child = frame.children[frame.childIndex];
-      frame.childIndex += 1;
-      stack.push({
-        node: child,
-        children: child.children,
-        childIndex: 0,
-        hasDescendantIssue: false,
-        issueStartIndex: issues.length,
-      });
-      continue;
-    }
-
-    const specific = isSpecificIssue(frame.node);
-    const selected =
-      specific || (frame.node.isError && !frame.hasDescendantIssue);
-    if (specific) {
-      issues.length = frame.issueStartIndex;
-    }
-    if (selected) {
-      issues.push(frame.node);
-    }
-
-    stack.pop();
-    const parent = stack.at(-1);
-    if (parent !== undefined) {
-      parent.hasDescendantIssue ||= frame.hasDescendantIssue || selected;
-    }
-  }
-
-  return issues;
-}
-
-function issuePriority(node) {
-  if (node.isError) {
-    return 0;
-  }
-  if (node.isMissing) {
-    return 1;
-  }
-  return 2;
-}
-
-function preferSpecificIssues(nodes) {
-  const issuesByRange = new Map();
-
-  for (const node of nodes) {
-    const key = `${node.startIndex}:${node.endIndex}`;
-    const existing = issuesByRange.get(key);
-    if (
-      existing === undefined ||
-      issuePriority(node) > issuePriority(existing)
-    ) {
-      issuesByRange.set(key, node);
-    }
-  }
-
-  return [...issuesByRange.values()].sort(
-    (left, right) =>
-      left.startIndex - right.startIndex || left.endIndex - right.endIndex,
-  );
-}
-
-function rangeForNode(document, node) {
-  return {
-    start: document.positionAt(node.startIndex),
-    end: document.positionAt(node.endIndex),
-  };
-}
-
-function collectLabels(rootNode, offset) {
-  const definitions = [];
-  let reference;
-  const stack = [rootNode];
-
-  while (stack.length > 0) {
-    const node = stack.pop();
-    if (node.type === "label_definition") {
-      definitions.push(node);
-    } else if (
-      node.type === "label_reference" &&
-      node.startIndex <= offset &&
-      offset < node.endIndex
-    ) {
-      reference = node;
-    }
-    stack.push(...node.children.toReversed());
-  }
-
-  return { definitions, reference };
-}
-
-export function createDiagnostics(document, dialect) {
-  const tree = parseDocument(document, dialect);
-
-  return preferSpecificIssues(collectIssueNodes(tree.rootNode)).map((node) => {
-    const { code, message } = descriptionFor(node, dialect);
-    return {
-      severity: DiagnosticSeverity.Error,
-      range: rangeForNode(document, node),
-      message,
-      code,
-      source: diagnosticSource,
-    };
-  });
-}
-
-export function createDefinitionLocations(document, position, dialect) {
-  const tree = parseDocument(document, dialect);
-  const { definitions, reference } = collectLabels(
-    tree.rootNode,
-    document.offsetAt(position),
-  );
-
-  if (reference === undefined) {
-    return null;
-  }
-
-  const locations = definitions
-    .filter((definition) => definition.text === reference.text)
-    .map((definition) => ({
-      uri: document.uri,
-      range: rangeForNode(document, definition),
-    }));
-
-  return locations.length === 0 ? null : locations;
-}