@platformos/platformos-language-server-common 0.0.2

package/src/linkedEditingRanges/providers/HtmlTagNameLinkedRangesProvider.ts

@@ -0,0 +1,28 @@
+import { LiquidHtmlNode } from '@platformos/liquid-html-parser';
+import { LinkedEditingRangeParams } from 'vscode-languageserver';
+import { DocumentManager } from '../../documents';
+import { BaseLinkedEditingRangesProvider } from '../BaseLinkedEditingRangesProvider';
+import { getHtmlElementNameRanges } from '../../utils/htmlTagNames';
+import { htmlElementNameWordPattern } from '../wordPattern';
+
+export class HtmlTagNameLinkedRangesProvider implements BaseLinkedEditingRangesProvider {
+  constructor(public documentManager: DocumentManager) {}
+
+  async linkedEditingRanges(
+    node: LiquidHtmlNode | null,
+    ancestors: LiquidHtmlNode[] | null,
+    params: LinkedEditingRangeParams,
+  ) {
+    if (!node || !ancestors) return null;
+
+    const textDocument = this.documentManager.get(params.textDocument.uri)?.textDocument;
+    if (!textDocument) return null;
+
+    const ranges = getHtmlElementNameRanges(node, ancestors, params, textDocument);
+    if (!ranges) return null;
+    return {
+      ranges,
+      wordPattern: htmlElementNameWordPattern,
+    };
+  }
+}

package/src/linkedEditingRanges/providers/index.ts

@@ -0,0 +1,2 @@
+export { EmptyHtmlTagLinkedRangesProvider } from './EmptyHtmlTagLinkedRangesProvider';
+export { HtmlTagNameLinkedRangesProvider } from './HtmlTagNameLinkedRangesProvider';

package/src/linkedEditingRanges/wordPattern.ts

@@ -0,0 +1,3 @@
+const nameCharStart = '[a-zA-Z]';
+const nameChar = '[a-zA-Z0-9-]';
+export const htmlElementNameWordPattern = `${nameCharStart}${nameChar}*`;

package/src/plugins/css.ts

@@ -0,0 +1,12 @@
+import { getCSSLanguageService, LanguageService } from 'vscode-css-languageservice';
+
+const cssLanguageService = getCSSLanguageService();
+
+const languageServices = {
+  css: cssLanguageService,
+};
+export type CSSLanguageServices = Record<'css' | 'less' | 'scss', LanguageService>;
+
+export function getCssLanguageService(kind: 'css'): LanguageService {
+  return languageServices[kind];
+}

package/src/progress.ts

@@ -0,0 +1,83 @@
+import { Connection } from 'vscode-languageserver';
+import { WorkDoneProgress, WorkDoneProgressCreateRequest } from 'vscode-languageserver-protocol';
+import { ClientCapabilities } from './ClientCapabilities';
+
+export interface IProgress {
+  start(title: string, initialMessage?: string): Promise<void>;
+  report(percentage?: number, message?: string): Promise<void>;
+  end(message?: string): Promise<void>;
+}
+
+/**
+ * A short hand for handling progress reporting to the language client.
+ *
+ * It handles all the LSP protocol details for you.
+ *
+ * @example
+ * const progress = Progress.create(connection, capabilities, progressToken);
+ * await progress.start('Starting progress');
+ * await progress.report(50, 'Halfway there');
+ * await progress.end('Finished');
+ */
+export class Progress {
+  constructor(private connection: Connection, private progressToken: string) {}
+
+  static create(
+    connection: Connection | undefined,
+    capabilities: ClientCapabilities | undefined,
+    progressToken: string,
+  ): IProgress {
+    if (!connection || !capabilities || !capabilities.hasProgressSupport) {
+      // If you don't have a connection, we give you a mock that doesn't do anything.
+      return {
+        start: async () => {},
+        report: async () => {},
+        end: async () => {},
+      } as IProgress;
+    }
+    return new Progress(connection!, progressToken);
+  }
+
+  async start(title: string) {
+    await this.connection.sendRequest(WorkDoneProgressCreateRequest.type, {
+      token: this.progressToken,
+    });
+    await this.connection.sendProgress(WorkDoneProgress.type, this.progressToken, {
+      kind: 'begin',
+      title,
+    });
+  }
+
+  async report(percentage?: number, message?: string) {
+    await this.connection.sendProgress(WorkDoneProgress.type, this.progressToken, {
+      kind: 'report',
+      message,
+      percentage,
+    });
+  }
+
+  async end(message?: string) {
+    await this.connection.sendProgress(WorkDoneProgress.type, this.progressToken, {
+      kind: 'end',
+      message,
+    });
+  }
+}
+
+/**
+ * Given a current/total and an offset, report the percent complete
+ * @param current - number of items processed from total
+ * @param total   - total number of items
+ * @param offset  - offset % to start at
+ *
+ * @example
+ * const offset = 50 // Start at 50%
+ * const current = 0
+ * const total = 100 // files or whatever
+ * percent(0, total, offset)   // 50 %
+ * percent(50, total, offset)  // 75 %
+ * percent(100, total, offset) // 100 %
+ */
+export function percent(current: number, total: number, offset: number = 0) {
+  return Math.round(offset + (current / total) * (100 - offset));
+}

package/src/rename/BaseRenameProvider.ts

@@ -0,0 +1,21 @@
+import { LiquidHtmlNode } from '@platformos/liquid-html-parser';
+import {
+  PrepareRenameParams,
+  PrepareRenameResult,
+  RenameParams,
+  WorkspaceEdit,
+} from 'vscode-languageserver-protocol';
+
+export interface BaseRenameProvider {
+  prepare(
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: PrepareRenameParams,
+  ): Promise<null | PrepareRenameResult>;
+
+  rename(
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: RenameParams,
+  ): Promise<null | WorkspaceEdit>;
+}

package/src/rename/RenameProvider.ts

@@ -0,0 +1,91 @@
+import { LiquidHtmlNode } from '@platformos/liquid-html-parser';
+import { SourceCodeType } from '@platformos/platformos-check-common';
+import {
+  PrepareRenameParams,
+  PrepareRenameResult,
+  RenameParams,
+  TextDocumentPositionParams,
+  WorkspaceEdit,
+} from 'vscode-languageserver-protocol';
+import { DocumentManager } from '../documents';
+import { findCurrentNode } from '@platformos/platformos-check-common';
+import { BaseRenameProvider } from './BaseRenameProvider';
+import { HtmlTagNameRenameProvider } from './providers/HtmlTagNameRenameProvider';
+import { LiquidVariableRenameProvider } from './providers/LiquidVariableRenameProvider';
+import { Connection } from 'vscode-languageserver';
+import { ClientCapabilities } from '../ClientCapabilities';
+import { FindThemeRootURI } from '../internal-types';
+
+/**
+ * RenameProvider is responsible for providing rename support for the theme language server.
+ *
+ * Rename is a pretty abstract concept, it can be renaming a tag name, a variable, a class name, etc.
+ */
+export class RenameProvider {
+  private providers: BaseRenameProvider[];
+
+  constructor(
+    connection: Connection,
+    clientCapabilities: ClientCapabilities,
+    private documentManager: DocumentManager,
+    findThemeRootURI: FindThemeRootURI,
+  ) {
+    this.providers = [
+      new HtmlTagNameRenameProvider(documentManager),
+      new LiquidVariableRenameProvider(
+        connection,
+        clientCapabilities,
+        documentManager,
+        findThemeRootURI,
+      ),
+    ];
+  }
+
+  /** Prepare is for telling if you can rename this thing or not, and what text to rename */
+  async prepare(params: PrepareRenameParams): Promise<null | PrepareRenameResult> {
+    const [currentNode, ancestors] = this.nodes(params);
+    if (currentNode === null || ancestors === null) {
+      return null;
+    }
+
+    const promises = this.providers.map((provider) =>
+      provider
+        .prepare(currentNode as LiquidHtmlNode, ancestors as LiquidHtmlNode[], params)
+        .catch(() => null),
+    );
+    const results = await Promise.all(promises);
+    return results.find(Boolean) ?? null;
+  }
+
+  /** Rename is for actually renaming something */
+  async rename(params: RenameParams): Promise<null | WorkspaceEdit> {
+    const [currentNode, ancestors] = this.nodes(params);
+    if (currentNode === null || ancestors === null) {
+      return null;
+    }
+
+    const promises = this.providers.map((provider) =>
+      provider
+        .rename(currentNode as LiquidHtmlNode, ancestors as LiquidHtmlNode[], params)
+        .catch(() => null),
+    );
+    const results = await Promise.all(promises);
+    return results.find(Boolean) ?? null;
+  }
+
+  /** a helper for getting the node under the cursor and its ancestry */
+  private nodes(
+    params: TextDocumentPositionParams,
+  ): [LiquidHtmlNode, LiquidHtmlNode[]] | [null, null] {
+    const document = this.documentManager.get(params.textDocument.uri);
+    if (!document || document.type !== SourceCodeType.LiquidHtml) {
+      return [null, null];
+    }
+
+    if (!(document.ast instanceof Error)) {
+      return findCurrentNode(document.ast, document.textDocument.offsetAt(params.position));
+    }
+
+    return [null, null];
+  }
+}

package/src/rename/providers/HtmlTagNameRenameProvider.spec.ts

@@ -0,0 +1,84 @@
+import { assert, beforeEach, describe, expect, it } from 'vitest';
+import { Position, TextDocumentEdit } from 'vscode-languageserver-protocol';
+import { DocumentManager } from '../../documents';
+import { RenameProvider } from '../RenameProvider';
+import { ClientCapabilities } from '../../ClientCapabilities';
+import { mockConnection } from '../../test/MockConnection';
+
+const mockRoot = 'file:';
+
+describe('HtmlTagNameRenameProvider', () => {
+  let documentManager: DocumentManager;
+  let provider: RenameProvider;
+
+  beforeEach(() => {
+    documentManager = new DocumentManager();
+    provider = new RenameProvider(
+      mockConnection(mockRoot),
+      new ClientCapabilities(),
+      documentManager,
+      async () => mockRoot,
+    );
+  });
+
+  it('returns null when the cursor is not over an HTML tag name', async () => {
+    const params = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 0),
+      newName: 'new-name',
+    };
+    documentManager.open(params.textDocument.uri, 'all text', 1);
+    const result = await provider.rename(params);
+    expect(result).to.be.null;
+  });
+
+  it('returns the correct workspace edit when renaming an HTML tag name', async () => {
+    const params = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 2),
+      newName: 'new-name',
+    };
+    documentManager.open(params.textDocument.uri, '<old><old></old></old>', 1);
+    const result = await provider.rename(params);
+    assert(result);
+    assert(result.documentChanges);
+    expect(result.documentChanges).to.have.lengthOf(1);
+    assert(result.documentChanges[0]);
+    assert(TextDocumentEdit.is(result.documentChanges[0]));
+    expect(result.documentChanges[0]!.edits).to.have.lengthOf(2);
+    expect(result.documentChanges[0]!.edits[0].newText).to.equal('new-name');
+    expect(result.documentChanges[0]!.edits[1].newText).to.equal('new-name');
+    const doc = documentManager.get(params.textDocument.uri)?.textDocument;
+    assert(doc);
+
+    // Now we apply the edits on the document to make sure the file after the edit
+    // is what we expect it to be
+    const textEdits = result.documentChanges[0]!.edits;
+    expect(textEdits).to.applyEdits(doc, '<new-name><old></old></new-name>');
+  });
+
+  it('also works on complext liquid + text html tag names', async () => {
+    const params = {
+      textDocument: { uri: 'file:///path/to/document.liquid' },
+      position: Position.create(0, 2),
+      newName: 'new-name',
+    };
+    documentManager.open(params.textDocument.uri, '<web--{{ comp }}>text</web--{{ comp }}>', 1);
+    const result = await provider.rename(params);
+    assert(result);
+    assert(result.documentChanges);
+    expect(result.documentChanges).to.have.lengthOf(1);
+    assert(result.documentChanges[0]);
+    assert(TextDocumentEdit.is(result.documentChanges[0]));
+    expect(result.documentChanges[0]!.edits).to.have.lengthOf(2);
+    expect(result.documentChanges[0]!.edits[0].newText).to.equal('new-name');
+    expect(result.documentChanges[0]!.edits[1].newText).to.equal('new-name');
+    const doc = documentManager.get(params.textDocument.uri)?.textDocument;
+    assert(doc);
+
+    // Now we apply the edits on the document to make sure the file after the edit
+    // is what we expect it to be
+    const textEdits = result.documentChanges[0]!.edits;
+    expect(textEdits).to.applyEdits(doc, '<new-name>text</new-name>');
+  });
+});

package/src/rename/providers/HtmlTagNameRenameProvider.ts

@@ -0,0 +1,59 @@
+import { LiquidHtmlNode } from '@platformos/liquid-html-parser';
+import {
+  PrepareRenameParams,
+  PrepareRenameResult,
+  Range,
+  RenameParams,
+  TextDocumentEdit,
+  TextEdit,
+  WorkspaceEdit,
+} from 'vscode-languageserver-protocol';
+import { DocumentManager } from '../../documents';
+import { getHtmlElementNameRanges } from '../../utils/htmlTagNames';
+import { BaseRenameProvider } from '../BaseRenameProvider';
+
+export class HtmlTagNameRenameProvider implements BaseRenameProvider {
+  constructor(private documentManager: DocumentManager) {}
+
+  async prepare(
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: PrepareRenameParams,
+  ): Promise<null | PrepareRenameResult> {
+    const textDocument = this.documentManager.get(params.textDocument.uri)?.textDocument;
+    if (!textDocument || !node || !ancestors) return null;
+
+    const ranges = getHtmlElementNameRanges(node, ancestors, params, textDocument);
+    if (!ranges || !ranges[0]) return null;
+
+    return {
+      range: ranges[0],
+      placeholder: textDocument.getText(ranges[0]),
+    };
+  }
+
+  async rename(
+    node: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: RenameParams,
+  ): Promise<null | WorkspaceEdit> {
+    const textDocument = this.documentManager.get(params.textDocument.uri)?.textDocument;
+    if (!textDocument || !node || !ancestors) return null;
+
+    const ranges = getHtmlElementNameRanges(node, ancestors, params, textDocument);
+    if (!ranges) return null;
+
+    const textDocumentEdit = TextDocumentEdit.create(
+      { uri: textDocument.uri, version: textDocument.version },
+      toTextEdits(ranges, params.newName),
+    );
+
+    return {
+      documentChanges: [textDocumentEdit],
+    };
+  }
+}
+
+function toTextEdits(ranges: Range[], newText: string): TextEdit[] {
+  return ranges.map((range) => TextEdit.replace(range, newText));
+}