@platformos/platformos-language-server-common 0.0.2

package/src/renamed/handlers/BlockRenameHandler.ts

@@ -0,0 +1,402 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import {
+  isBlockSchema,
+  isError,
+  isSectionSchema,
+  JSONNode,
+  nodeAtPath,
+  parseJSON,
+  path,
+  Preset,
+  Section,
+  SourceCodeType,
+  Template,
+  ThemeBlock,
+  visit,
+} from '@platformos/platformos-check-common';
+import { Connection } from 'vscode-languageserver';
+import {
+  ApplyWorkspaceEditRequest,
+  Range,
+  RenameFilesParams,
+  TextDocumentEdit,
+  AnnotatedTextEdit as TextEdit,
+  WorkspaceEdit,
+} from 'vscode-languageserver-protocol';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { ClientCapabilities } from '../../ClientCapabilities';
+import {
+  AugmentedJsonSourceCode,
+  AugmentedLiquidSourceCode,
+  AugmentedSourceCode,
+  DocumentManager,
+  isJsonSourceCode,
+  isLiquidSourceCode,
+} from '../../documents';
+import { blockName, isBlock, isSection, isSectionGroup, isTemplate } from '../../utils/uri';
+import { BaseRenameHandler } from '../BaseRenameHandler';
+import { isValidSectionGroup, isValidTemplate } from './utils';
+import { FindThemeRootURI } from '../../internal-types';
+
+type DocumentChange = TextDocumentEdit;
+
+const annotationId = 'renameBlock';
+
+/**
+ * The BlockRenameHandler will handle block renames.
+ *
+ * Whenever a block gets renamed, a lot of things need to happen:
+ *   1. References in files with a {% schema %} must be changed
+ *   2. References in template files must be changed
+ *   3. References in section groups must be changed
+ *   4. References in {% content_for "block", type: "oldName" %} must be changed
+ *
+ * Things we're not doing:
+ *   5. If isPublic(oldName) && isPrivate(newName) && "schema.blocks" accepts "@theme",
+ *      Then the block should be added to the "blocks" array
+ *
+ *    Reasoning: this is more noisy than useful. a now-private block
+ *      could be used by a preset, template or section group. Doing a
+ *      toil-free rename would require visiting all preset, templates and
+ *      section groups to see if a parent that uses the new block name
+ *      was supporting "@theme" blocks. It's a lot. It's O(S*(S+T+SG)) where
+ *      S is the number of sections, T is the number of templates and SG is the
+ *      number of section groups. It's not worth it.
+ *
+ *      This stuff is complicated enough as it is 😅.
+ */
+export class BlockRenameHandler implements BaseRenameHandler {
+  constructor(
+    private documentManager: DocumentManager,
+    private connection: Connection,
+    private capabilities: ClientCapabilities,
+    private findThemeRootURI: FindThemeRootURI,
+  ) {}
+
+  async onDidRenameFiles(params: RenameFilesParams): Promise<void> {
+    if (!this.capabilities.hasApplyEditSupport) return;
+
+    const relevantRenames = params.files.filter(
+      (file) => isBlock(file.oldUri) && isBlock(file.newUri),
+    );
+
+    // Only preload if you have something to do (folder renames not supported yet).
+    if (relevantRenames.length !== 1) return;
+    const rename = relevantRenames[0];
+    const rootUri = await this.findThemeRootURI(path.dirname(params.files[0].oldUri));
+    if (!rootUri) return;
+    await this.documentManager.preload(rootUri);
+    const theme = this.documentManager.theme(rootUri, true);
+    const liquidFiles = theme.filter(isLiquidSourceCode);
+    const sectionsAndBlocks = liquidFiles.filter(
+      (file) => isBlock(file.uri) || isSection(file.uri),
+    );
+    const templates = theme.filter(isJsonSourceCode).filter((file) => isTemplate(file.uri));
+    const sectionGroups = theme.filter(isJsonSourceCode).filter((file) => isSectionGroup(file.uri));
+    const oldBlockName = blockName(rename.oldUri);
+    const newBlockName = blockName(rename.newUri);
+    const editLabel = `Rename block '${oldBlockName}' to '${newBlockName}'`;
+    const workspaceEdit: WorkspaceEdit = {
+      documentChanges: [],
+      changeAnnotations: {
+        [annotationId]: {
+          label: editLabel,
+          needsConfirmation: false,
+        },
+      },
+    };
+
+    // We need to keep track of sections that have local blocks, because we
+    // shouldn't rename those. Only uses of "@theme" or specifically named blocks
+    // should be renamed when the blocks/*.liquid file is renamed.
+    const sectionsWithLocalBlocks = new Set();
+    const sectionAndBlocksChanges: (DocumentChange | null)[] = await Promise.all(
+      sectionsAndBlocks.map(
+        this.getSchemaChanges(sectionsWithLocalBlocks, oldBlockName, newBlockName),
+      ),
+    );
+
+    // All the templates/*.json files need to be updated with the new block name
+    // when the old block name wasn't a local block.
+    const [templateChanges, sectionGroupChanges, contentForChanges] = await Promise.all([
+      Promise.all(
+        templates.map(this.getTemplateChanges(oldBlockName, newBlockName, sectionsWithLocalBlocks)),
+      ),
+      Promise.all(
+        sectionGroups.map(
+          this.getSectionGroupChanges(oldBlockName, newBlockName, sectionsWithLocalBlocks),
+        ),
+      ),
+      Promise.all(liquidFiles.map(this.getContentForChanges(oldBlockName, newBlockName))),
+    ]);
+
+    for (const docChange of [
+      ...sectionAndBlocksChanges,
+      ...templateChanges,
+      ...sectionGroupChanges,
+    ]) {
+      if (docChange !== null) {
+        workspaceEdit.documentChanges!.push(docChange);
+      }
+    }
+
+    // Because contentForChanges could make a change to an existing document, we need
+    // to group the edits together by document. Or else we might have index
+    // drifting issues.
+    for (const docChange of contentForChanges) {
+      if (docChange !== null) {
+        const existingDocChange = (workspaceEdit.documentChanges as DocumentChange[]).find(
+          (dc) => dc.textDocument.uri === docChange?.textDocument.uri,
+        );
+        if (existingDocChange) {
+          existingDocChange.edits.push(...docChange.edits);
+        } else {
+          workspaceEdit.documentChanges!.push(docChange);
+        }
+      }
+    }
+
+    if (workspaceEdit.documentChanges!.length === 0) {
+      console.error('Nothing to do!');
+      return;
+    }
+
+    await this.connection.sendRequest(ApplyWorkspaceEditRequest.type, {
+      label: editLabel,
+      edit: workspaceEdit,
+    });
+  }
+
+  private getSchemaChanges(
+    sectionsWithLocalBlocks: Set<unknown>,
+    oldBlockName: string,
+    newBlockName: string,
+  ) {
+    return async (sourceCode: AugmentedLiquidSourceCode) => {
+      if (sourceCode.ast instanceof Error) return null;
+      const textDocument = sourceCode.textDocument;
+      const schema = await sourceCode.getSchema();
+      if (!isBlockSchema(schema) && !isSectionSchema(schema)) return null;
+      if (isError(schema.validSchema) || isError(schema.ast)) return null;
+      const { validSchema, ast, offset } = schema;
+
+      const edits: TextEdit[] = [];
+      if (validSchema.blocks) {
+        for (let i = 0; i < validSchema.blocks.length; i++) {
+          const blockDef = validSchema.blocks[i];
+          if (isLocalBlock(blockDef)) {
+            // If the section has a local blocks, we shouldn't rename
+            // anything in this file.
+            if (isSectionSchema(schema)) {
+              sectionsWithLocalBlocks.add(schema.name);
+            }
+            return null;
+          }
+
+          if (blockDef.type !== oldBlockName) continue;
+          const node = nodeAtPath(ast, ['blocks', i, 'type']);
+          edits.push({
+            annotationId,
+            newText: newBlockName,
+            range: Range.create(
+              textDocument.positionAt(offset + node!.loc!.start.offset + 1),
+              textDocument.positionAt(offset + node!.loc!.end.offset - 1),
+            ),
+          });
+        }
+      }
+
+      const presetEdits = (
+        presetBlock: Preset.Preset | Preset.Block | undefined,
+        path: (string | number)[],
+      ): TextEdit[] => {
+        if (!presetBlock || !('blocks' in presetBlock)) return [];
+        if (Array.isArray(presetBlock.blocks)) {
+          return presetBlock.blocks.flatMap((block, index) => {
+            const edits = presetEdits(block, [...path, 'blocks', index]);
+            if (block.type === oldBlockName) {
+              const node = nodeAtPath(ast, [...path, 'blocks', index, 'type']);
+              edits.push({
+                annotationId,
+                newText: newBlockName,
+                range: Range.create(
+                  textDocument.positionAt(offset + node!.loc!.start.offset + 1),
+                  textDocument.positionAt(offset + node!.loc!.end.offset - 1),
+                ),
+              });
+            }
+            return edits;
+          });
+        } else if (typeof presetBlock.blocks === 'object') {
+          return Object.entries(presetBlock.blocks).flatMap(([key, block]) => {
+            const edits = presetEdits(block, [...path, 'blocks', key]);
+            if (block.type === oldBlockName) {
+              const node = nodeAtPath(ast, [...path, 'blocks', key, 'type']);
+              edits.push({
+                annotationId,
+                newText: newBlockName,
+                range: Range.create(
+                  textDocument.positionAt(offset + node!.loc!.start.offset + 1),
+                  textDocument.positionAt(offset + node!.loc!.end.offset - 1),
+                ),
+              });
+            }
+            return edits;
+          });
+        } else {
+          return [];
+        }
+      };
+
+      if (validSchema.presets) {
+        edits.push(
+          ...validSchema.presets.flatMap((preset, i) => presetEdits(preset, ['presets', i])),
+        );
+      }
+
+      if (edits.length === 0) return null;
+
+      return documentChanges(sourceCode, edits);
+    };
+  }
+
+  private getTemplateChanges(
+    oldBlockName: string,
+    newBlockName: string,
+    sectionsWithLocalBlocks: Set<unknown>,
+  ) {
+    return async (sourceCode: AugmentedJsonSourceCode) => {
+      // assuming that the JSON is valid...
+      const { textDocument, ast, source } = sourceCode;
+      const parsed = parseJSON(source);
+      if (!parsed || isError(parsed) || isError(ast)) return null;
+      const getBlocksEdits = getBlocksEditsFactory(oldBlockName, newBlockName, textDocument, ast);
+      const edits: TextEdit[] = !isValidTemplate(parsed)
+        ? []
+        : Object.entries(parsed.sections).flatMap(([key, section]) => {
+            if (
+              'blocks' in section &&
+              !!section.blocks &&
+              !sectionsWithLocalBlocks.has(section.type) // don't rename local blocks
+            ) {
+              return getBlocksEdits(section.blocks, ['sections', key, 'blocks']);
+            } else {
+              return [];
+            }
+          });
+
+      if (edits.length === 0) return null;
+
+      return documentChanges(sourceCode, edits);
+    };
+  }
+
+  private getSectionGroupChanges(
+    oldBlockName: string,
+    newBlockName: string,
+    sectionsWithLocalBlocks: Set<unknown>,
+  ) {
+    return async (sourceCode: AugmentedJsonSourceCode) => {
+      const { textDocument, ast, source } = sourceCode;
+      const parsed = parseJSON(source);
+      if (!parsed || isError(parsed) || isError(ast)) return null;
+      const getBlocksEdits = getBlocksEditsFactory(oldBlockName, newBlockName, textDocument, ast);
+      const edits: TextEdit[] = !isValidSectionGroup(parsed)
+        ? []
+        : Object.entries(parsed.sections).flatMap(([key, section]) => {
+            if (
+              'blocks' in section &&
+              !!section.blocks &&
+              !sectionsWithLocalBlocks.has(section.type) // don't rename local blocks
+            ) {
+              return getBlocksEdits(section.blocks, ['sections', key, 'blocks']);
+            } else {
+              return [];
+            }
+          });
+
+      if (edits.length === 0) return null;
+
+      return documentChanges(sourceCode, edits);
+    };
+  }
+
+  private getContentForChanges(oldBlockName: string, newBlockName: string) {
+    return async (sourceCode: AugmentedLiquidSourceCode) => {
+      const { textDocument, ast } = sourceCode;
+      if (isError(ast)) return null;
+
+      const edits = await visit<SourceCodeType.LiquidHtml, TextEdit>(ast, {
+        async LiquidTag(node) {
+          if (node.name !== 'content_for') return;
+          if (typeof node.markup === 'string') return;
+          if (node.markup.contentForType.value !== 'block') return;
+          const typeNode = node.markup.args.find((arg) => arg.name === 'type');
+          if (
+            !typeNode ||
+            typeNode.value.type !== NodeTypes.String ||
+            typeNode.value.value !== oldBlockName
+          ) {
+            return;
+          }
+
+          return {
+            annotationId,
+            newText: newBlockName,
+            range: Range.create(
+              textDocument.positionAt(typeNode.value.position.start + 1),
+              textDocument.positionAt(typeNode.value.position.end - 1),
+            ),
+          };
+        },
+      });
+
+      if (edits.length === 0) return null;
+
+      return documentChanges(sourceCode, edits);
+    };
+  }
+}
+
+function isLocalBlock(blockDef: ThemeBlock.Block | Section.Block): blockDef is Section.LocalBlock {
+  return 'name' in blockDef && typeof blockDef.name === 'string';
+}
+
+function getBlocksEditsFactory(
+  oldBlockName: string,
+  newBlockName: string,
+  textDocument: TextDocument,
+  ast: JSONNode,
+) {
+  return function getBlocksEdits(
+    blocks: Record<string, Template.Block> | undefined,
+    path: (string | number)[],
+  ): TextEdit[] {
+    if (!blocks) return [];
+    return Object.entries(blocks).flatMap(([key, block]) => {
+      const edits = getBlocksEdits(block.blocks, [...path, key, 'blocks']);
+      if (block.type === oldBlockName) {
+        const node = nodeAtPath(ast, [...path, key, 'type'])!;
+        edits.push({
+          annotationId,
+          newText: newBlockName,
+          range: Range.create(
+            textDocument.positionAt(node.loc!.start.offset + 1),
+            textDocument.positionAt(node.loc!.end.offset - 1),
+          ),
+        });
+      }
+      return edits;
+    });
+  };
+}
+
+function documentChanges(sourceCode: AugmentedSourceCode, edits: TextEdit[]): DocumentChange {
+  return {
+    textDocument: {
+      uri: sourceCode.uri,
+      version: sourceCode.version ?? null /* null means file from disk in this API */,
+    },
+    edits,
+  };
+}

package/src/renamed/handlers/PartialRenameHandler.spec.ts

@@ -0,0 +1,153 @@
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+import { assert, beforeEach, describe, expect, it } from 'vitest';
+import { TextDocumentEdit } from 'vscode-json-languageservice';
+import { ApplyWorkspaceEditParams } from 'vscode-languageserver-protocol';
+import { ClientCapabilities } from '../../ClientCapabilities';
+import { DocumentManager } from '../../documents';
+import { MockConnection, mockConnection } from '../../test/MockConnection';
+import { RenameHandler } from '../RenameHandler';
+
+describe('Module: PartialRenameHandler', () => {
+  const mockRoot = 'mock-fs:';
+  const findThemeRootURI = async () => mockRoot;
+  let capabilities: ClientCapabilities;
+  let documentManager: DocumentManager;
+  let handler: RenameHandler;
+  let connection: MockConnection;
+  let fs: MockFileSystem;
+  beforeEach(() => {
+    connection = mockConnection(mockRoot);
+    connection.spies.sendRequest.mockReturnValue(Promise.resolve(true));
+    capabilities = new ClientCapabilities();
+    fs = new MockFileSystem(
+      {
+        'sections/section.liquid': `<div>{% render 'oldName', foo: 'bar' %}oldName</div>`,
+        'blocks/block.liquid': `<div>{% render 'oldName', foo: 'baz' %}</div>`,
+        'app/views/partials/oldName.liquid': `<div>oldName{%</div>`,
+        'app/views/partials/other.liquid': `<div>{% render 'oldName' %}{% render 'other' %}</div>`,
+      },
+      mockRoot,
+    );
+    documentManager = new DocumentManager(fs);
+    handler = new RenameHandler(connection, capabilities, documentManager, findThemeRootURI);
+  });
+
+  describe('when the client does not support workspace/applyEdit', () => {
+    beforeEach(() => {
+      capabilities.setup({
+        workspace: {
+          applyEdit: false,
+        },
+      });
+    });
+
+    it('does nothing', async () => {
+      await handler.onDidRenameFiles({
+        files: [
+          {
+            oldUri: 'mock-fs:/app/views/partials/oldName.liquid',
+            newUri: 'mock-fs:/app/views/partials/newName.liquid',
+          },
+        ],
+      });
+      expect(connection.spies.sendRequest).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('when the client supports workspace/applyEdit', () => {
+    beforeEach(() => {
+      capabilities.setup({
+        workspace: {
+          applyEdit: true,
+        },
+      });
+    });
+
+    it('returns a needConfirmation: false workspace edit for renaming a partial', async () => {
+      await handler.onDidRenameFiles({
+        files: [
+          {
+            oldUri: 'mock-fs:/app/views/partials/oldName.liquid',
+            newUri: 'mock-fs:/app/views/partials/newName.liquid',
+          },
+        ],
+      });
+
+      const expectedTextEdit = {
+        range: expect.any(Object),
+        newText: 'newName',
+      };
+
+      expect(connection.spies.sendRequest).toHaveBeenCalledWith('workspace/applyEdit', {
+        label: "Rename partial 'oldName' to 'newName'",
+        edit: {
+          changeAnnotations: {
+            renamePartial: {
+              label: `Rename partial 'oldName' to 'newName'`,
+              needsConfirmation: false,
+            },
+          },
+          documentChanges: [
+            {
+              textDocument: {
+                uri: 'mock-fs:/sections/section.liquid',
+                version: null,
+              },
+              edits: [expectedTextEdit],
+              annotationId: 'renamePartial',
+            },
+            {
+              textDocument: {
+                uri: 'mock-fs:/blocks/block.liquid',
+                version: null,
+              },
+              edits: [expectedTextEdit],
+              annotationId: 'renamePartial',
+            },
+            {
+              textDocument: {
+                uri: 'mock-fs:/app/views/partials/other.liquid',
+                version: null,
+              },
+              edits: [expectedTextEdit],
+              annotationId: 'renamePartial',
+            },
+          ],
+        },
+      });
+    });
+
+    it('replaces the correct text in the documents', async () => {
+      await handler.onDidRenameFiles({
+        files: [
+          {
+            oldUri: 'mock-fs:/app/views/partials/oldName.liquid',
+            newUri: 'mock-fs:/app/views/partials/newName.liquid',
+          },
+        ],
+      });
+
+      const params: ApplyWorkspaceEditParams = connection.spies.sendRequest.mock.calls[0][1];
+      const expectedFs = new MockFileSystem(
+        {
+          'sections/section.liquid': `<div>{% render 'newName', foo: 'bar' %}oldName</div>`,
+          'blocks/block.liquid': `<div>{% render 'newName', foo: 'baz' %}</div>`,
+          'app/views/partials/newName.liquid': `<div>oldName{%</div>`,
+          'app/views/partials/other.liquid': `<div>{% render 'newName' %}{% render 'other' %}</div>`,
+        },
+        'mock-fs:',
+      );
+
+      assert(params.edit);
+      assert(params.edit.documentChanges);
+      for (const docChange of params.edit.documentChanges) {
+        assert(TextDocumentEdit.is(docChange));
+        const uri = docChange.textDocument.uri;
+        const edits = docChange.edits;
+        const initialDoc = await fs.readFile(uri);
+        const expectedDoc = await expectedFs.readFile(uri);
+        expect(edits).to.applyEdits(initialDoc, expectedDoc);
+      }
+    });
+  });
+});

package/src/renamed/handlers/PartialRenameHandler.ts

@@ -0,0 +1,110 @@
+import { LiquidTag, NamedTags, NodeTypes } from '@platformos/liquid-html-parser';
+import { path, SourceCodeType, visit } from '@platformos/platformos-check-common';
+import { Connection } from 'vscode-languageserver';
+import {
+  ApplyWorkspaceEditRequest,
+  Range,
+  RenameFilesParams,
+  TextEdit,
+  WorkspaceEdit,
+} from 'vscode-languageserver-protocol';
+import { ClientCapabilities } from '../../ClientCapabilities';
+import { DocumentManager, isLiquidSourceCode } from '../../documents';
+import { isPartial, partialName } from '../../utils/uri';
+import { BaseRenameHandler } from '../BaseRenameHandler';
+import { FindThemeRootURI } from '../../internal-types';
+
+/**
+ * The PartialRenameHandler will handle partial renames.
+ *
+ * We'll change all the render and include tags that reference the old partial
+ * to reference the new partial.
+ *
+ *   {% render 'oldName' %} -> {% render 'newName' %}
+ *
+ * We'll do this by visiting all the liquid files in the theme and looking for
+ * render and include tags that reference the old partial. We'll then create a
+ * WorkspaceEdit that changes the references to the new partial.
+ */
+export class PartialRenameHandler implements BaseRenameHandler {
+  constructor(
+    private documentManager: DocumentManager,
+    private connection: Connection,
+    private capabilities: ClientCapabilities,
+    private findThemeRootURI: FindThemeRootURI,
+  ) {}
+
+  async onDidRenameFiles(params: RenameFilesParams): Promise<void> {
+    if (!this.capabilities.hasApplyEditSupport) return;
+    const relevantRenames = params.files.filter(
+      (file) => isPartial(file.oldUri) && isPartial(file.newUri),
+    );
+
+    // Only preload if you have something to do (folder renames are not supported)
+    if (relevantRenames.length !== 1) return;
+    const rename = relevantRenames[0];
+    const rootUri = await this.findThemeRootURI(path.dirname(params.files[0].oldUri));
+    if (!rootUri) return;
+    await this.documentManager.preload(rootUri);
+    const theme = this.documentManager.theme(rootUri, true);
+    const liquidSourceCodes = theme.filter(isLiquidSourceCode);
+    const oldPartialName = partialName(rename.oldUri);
+    const newPartialName = partialName(rename.newUri);
+    const editLabel = `Rename partial '${oldPartialName}' to '${newPartialName}'`;
+    const annotationId = 'renamePartial';
+    const workspaceEdit: WorkspaceEdit = {
+      documentChanges: [],
+      changeAnnotations: {
+        [annotationId]: {
+          label: editLabel,
+          needsConfirmation: false,
+        },
+      },
+    };
+
+    for (const sourceCode of liquidSourceCodes) {
+      if (sourceCode.ast instanceof Error) continue;
+      const textDocument = sourceCode.textDocument;
+      const edits: TextEdit[] = await visit<SourceCodeType.LiquidHtml, TextEdit>(sourceCode.ast, {
+        async LiquidTag(node: LiquidTag) {
+          if (node.name !== NamedTags.render && node.name !== NamedTags.include) {
+            return;
+          }
+          if (typeof node.markup === 'string') {
+            return;
+          }
+          const snippet = node.markup.snippet;
+          if (snippet.type === NodeTypes.String && snippet.value === oldPartialName) {
+            return {
+              newText: `${newPartialName}`,
+              range: Range.create(
+                textDocument.positionAt(snippet.position.start + 1), // +1 to skip the opening quote
+                textDocument.positionAt(snippet.position.end - 1), // -1 to skip the closing quote
+              ),
+            };
+          }
+        },
+      });
+
+      if (edits.length === 0) continue;
+      workspaceEdit.documentChanges!.push({
+        textDocument: {
+          uri: textDocument.uri,
+          version: sourceCode.version ?? null /* null means file from disk in this API */,
+        },
+        annotationId,
+        edits,
+      });
+    }
+
+    if (workspaceEdit.documentChanges!.length === 0) {
+      console.error('Nothing to do!');
+      return;
+    }
+
+    await this.connection.sendRequest(ApplyWorkspaceEditRequest.type, {
+      label: editLabel,
+      edit: workspaceEdit,
+    });
+  }
+}