@platformos/platformos-language-server-common 0.0.2

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

@@ -0,0 +1,321 @@
+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: SectionRenameHandler', () => {
+  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/old-name.liquid': `
+            {% schema %}
+              {
+                "name": "Old name"
+              }
+            {% endschema %}`,
+
+        'layout/theme.liquid': `
+            {% section 'old-name' %}
+          `,
+
+        'sections/header.json': `
+            {
+              "type": "header",
+              "name": "Header",
+              "sections": {
+                "section-id": {
+                  "type": "old-name"
+                }
+              },
+              "order": ["section-id"]
+            }`,
+
+        'templates/index.json': `
+            {
+              "sections": {
+                "section-id": {
+                  "type": "old-name"
+                }
+              },
+              "order": ["section-id"]
+            }`,
+      },
+      mockRoot,
+    );
+    documentManager = new DocumentManager(
+      fs, // filesystem
+      undefined, // optional mode getter
+      undefined, // optional mode map
+      async () => 'theme', // getModeForURI
+      async () => true, // isValidSchema - assume all schemas are valid in tests
+    );
+    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:/sections/old-name.liquid',
+            newUri: 'mock-fs:/sections/new-name.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 section', async () => {
+      await handler.onDidRenameFiles({
+        files: [
+          {
+            oldUri: 'mock-fs:/sections/old-name.liquid',
+            newUri: 'mock-fs:/sections/new-name.liquid',
+          },
+        ],
+      });
+
+      const replaceWithNewNameTextEditAtAnyLocation = {
+        annotationId: 'renameSection',
+        newText: 'new-name',
+        range: {
+          start: expect.any(Object),
+          end: expect.any(Object),
+        },
+      };
+
+      const templateTextEdits = [
+        // Section type is updated in the section sections array
+        replaceWithNewNameTextEditAtAnyLocation,
+      ];
+
+      const sectionGroupTextEdits = [
+        // Section type is updated in the section sections array,
+        replaceWithNewNameTextEditAtAnyLocation,
+      ];
+
+      const sectionTagTextEdits = [
+        // Over {% section 'old-name' %}
+        replaceWithNewNameTextEditAtAnyLocation,
+      ];
+
+      expect(connection.spies.sendRequest).toHaveBeenCalledWith('workspace/applyEdit', {
+        label: "Rename section 'old-name' to 'new-name'",
+        edit: {
+          changeAnnotations: {
+            renameSection: {
+              label: `Rename section 'old-name' to 'new-name'`,
+              needsConfirmation: false,
+            },
+          },
+          documentChanges: expect.arrayContaining([
+            {
+              textDocument: {
+                uri: 'mock-fs:/layout/theme.liquid',
+                version: null,
+              },
+              edits: sectionTagTextEdits,
+            },
+            {
+              textDocument: {
+                uri: 'mock-fs:/templates/index.json',
+                version: null,
+              },
+              edits: templateTextEdits,
+            },
+            {
+              textDocument: {
+                uri: 'mock-fs:/sections/header.json',
+                version: null,
+              },
+              edits: sectionGroupTextEdits,
+            },
+          ]),
+        },
+      });
+    });
+
+    it('replaces the correct text in the documents', async () => {
+      await handler.onDidRenameFiles({
+        files: [
+          {
+            oldUri: 'mock-fs:/sections/old-name.liquid',
+            newUri: 'mock-fs:/sections/new-name.liquid',
+          },
+        ],
+      });
+
+      const params: ApplyWorkspaceEditParams = connection.spies.sendRequest.mock.calls[0][1];
+      const expectedFs = new MockFileSystem(
+        {
+          'sections/new-name.liquid': `
+            {% schema %}
+              {
+                "name": "Old name"
+              }
+            {% endschema %}`,
+
+          'layout/theme.liquid': `
+            {% section 'new-name' %}
+          `,
+
+          'sections/header.json': `
+            {
+              "type": "header",
+              "name": "Header",
+              "sections": {
+                "section-id": {
+                  "type": "new-name"
+                }
+              },
+              "order": ["section-id"]
+            }`,
+
+          'templates/index.json': `
+            {
+              "sections": {
+                "section-id": {
+                  "type": "new-name"
+                }
+              },
+              "order": ["section-id"]
+            }`,
+        },
+        mockRoot,
+      );
+
+      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);
+      }
+    });
+
+    it('preserves local section definitions', async () => {
+      fs = new MockFileSystem(
+        {
+          // a "theme" text section exists
+          'sections/text.liquid': `
+            {% schema %}
+              { "name": "text section" }
+            {% endschema %}`,
+
+          // this section uses a local section of type "text"
+          'sections/local.liquid': `
+            {% schema %}
+              {
+                "name": "Section with local sections",
+                "sections": [
+                  {
+                    "type": "text",
+                    "name": "Local text section"
+                  }
+                ],
+                "presets": [
+                  {
+                    "name": "Because text is a local section definition, this preset won't get a rename",
+                    "sections": [
+                      { "type": "text" }
+                    ]
+                  }
+                ]
+              }
+            {% endschema %}`,
+
+          // This section group uses the local section that uses the local section, no rename needed
+          'sections/header.json': JSON.stringify({
+            type: 'header',
+            name: 'Header',
+            sections: {
+              local_id: {
+                type: 'local',
+                sections: {
+                  text_tqQTNE: {
+                    type: 'text',
+                  },
+                },
+                section_order: ['text_tqQTNE'],
+              },
+            },
+            order: ['local_id'],
+          }),
+
+          // This template uses the section that uses the local section, no rename needed
+          'templates/index.json': JSON.stringify({
+            sections: {
+              local: {
+                type: 'local',
+                sections: {
+                  text_tqQTNE: {
+                    type: 'text',
+                  },
+                },
+                section_order: ['text_tqQTNE'],
+              },
+            },
+          }),
+        },
+        mockRoot,
+      );
+      documentManager = new DocumentManager(
+        fs,
+        undefined,
+        undefined,
+        async () => 'theme',
+        async () => true,
+      );
+      handler = new RenameHandler(connection, capabilities, documentManager, findThemeRootURI);
+
+      await handler.onDidRenameFiles({
+        files: [
+          {
+            oldUri: 'mock-fs:/sections/text.liquid',
+            newUri: 'mock-fs:/sections/poetry.liquid',
+          },
+        ],
+      });
+
+      // Check if sendRequest was called at all
+      expect(connection.spies.sendRequest).not.toHaveBeenCalled();
+    });
+  });
+});

package/src/renamed/handlers/SectionRenameHandler.ts

@@ -0,0 +1,224 @@
+import { LiquidString } from '@platformos/liquid-html-parser';
+import {
+  isError,
+  LiteralNode,
+  nodeAtPath,
+  parseJSON,
+  path,
+  SourceCodeType,
+  visit,
+} from '@platformos/platformos-check-common';
+import { Connection } from 'vscode-languageserver';
+import {
+  AnnotatedTextEdit,
+  ApplyWorkspaceEditRequest,
+  Range,
+  RenameFilesParams,
+  TextDocumentEdit,
+  AnnotatedTextEdit as TextEdit,
+  WorkspaceEdit,
+} from 'vscode-languageserver-protocol';
+import { ClientCapabilities } from '../../ClientCapabilities';
+import {
+  AugmentedJsonSourceCode,
+  AugmentedLiquidSourceCode,
+  AugmentedSourceCode,
+  DocumentManager,
+  isJsonSourceCode,
+  isLiquidSourceCode,
+} from '../../documents';
+import { FindThemeRootURI } from '../../internal-types';
+import { isSection, isSectionGroup, isTemplate, sectionName } from '../../utils/uri';
+import { BaseRenameHandler } from '../BaseRenameHandler';
+import { isValidSectionGroup, isValidTemplate } from './utils';
+
+type DocumentChange = TextDocumentEdit;
+
+const annotationId = 'renameSection';
+
+/**
+ * The SectionRenameHandler will handle section renames
+ *
+ * Whenever a section gets renamed, a lot of things need to happen:
+ *   2. References in template files must be changed
+ *   3. References in section groups must be changed
+ *   4. References like {% section "oldName" %} must be changed
+ */
+export class SectionRenameHandler 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) => isSection(file.oldUri) && isSection(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 templates = theme.filter(isJsonSourceCode).filter((file) => isTemplate(file.uri));
+    const sectionGroups = theme.filter(isJsonSourceCode).filter((file) => isSectionGroup(file.uri));
+    const oldSectionName = sectionName(rename.oldUri);
+    const newSectionName = sectionName(rename.newUri);
+    const editLabel = `Rename section '${oldSectionName}' to '${newSectionName}'`;
+    const workspaceEdit: WorkspaceEdit = {
+      documentChanges: [],
+      changeAnnotations: {
+        [annotationId]: {
+          label: editLabel,
+          needsConfirmation: false,
+        },
+      },
+    };
+
+    // 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, sectionTagChanges] = await Promise.all([
+      Promise.all(templates.map(this.getTemplateChanges(oldSectionName, newSectionName))),
+      Promise.all(sectionGroups.map(this.getSectionGroupChanges(oldSectionName, newSectionName))),
+      Promise.all(liquidFiles.map(this.getSectionTagChanges(oldSectionName, newSectionName))),
+    ]);
+
+    for (const docChange of [...templateChanges, ...sectionGroupChanges]) {
+      if (docChange !== null) {
+        workspaceEdit.documentChanges!.push(docChange);
+      }
+    }
+
+    // Because section tag changes 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 sectionTagChanges) {
+      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 getTemplateChanges(oldSectionName: string, newSectionName: string) {
+    return async (sourceCode: AugmentedJsonSourceCode) => {
+      const { textDocument, ast, source } = sourceCode;
+      const parsed = parseJSON(source);
+      if (!parsed || isError(parsed) || isError(ast)) return null;
+      const edits: AnnotatedTextEdit[] = !isValidTemplate(parsed)
+        ? []
+        : Object.entries(parsed.sections)
+            .filter(([_key, section]) => section.type === oldSectionName)
+            .map(([key]) => {
+              const node = nodeAtPath(ast, ['sections', key, 'type']) as LiteralNode;
+              return {
+                annotationId,
+                newText: newSectionName,
+                range: Range.create(
+                  textDocument.positionAt(node.loc.start.offset + 1),
+                  textDocument.positionAt(node.loc.end.offset - 1),
+                ),
+              } as AnnotatedTextEdit;
+            });
+
+      if (edits.length === 0) return null;
+
+      return documentChanges(sourceCode, edits);
+    };
+  }
+
+  // Awfully similar except for the isValidSectionGroup check and the types of the objects.
+  // Feels like a coincidence that the types are so similar. I'm not sure this should be DRY'd up.
+  private getSectionGroupChanges(oldSectionName: string, newSectionName: string) {
+    return async (sourceCode: AugmentedJsonSourceCode) => {
+      const { textDocument, ast, source } = sourceCode;
+      const parsed = parseJSON(source);
+      if (!parsed || isError(parsed) || isError(ast)) return null;
+      const edits: TextEdit[] = !isValidSectionGroup(parsed)
+        ? []
+        : Object.entries(parsed.sections)
+            .filter(([_key, section]) => section.type === oldSectionName)
+            .map(([key]) => {
+              const node = nodeAtPath(ast, ['sections', key, 'type']) as LiteralNode;
+              return {
+                annotationId,
+                newText: newSectionName,
+                range: Range.create(
+                  textDocument.positionAt(node.loc.start.offset + 1),
+                  textDocument.positionAt(node.loc.end.offset - 1),
+                ),
+              } as AnnotatedTextEdit;
+            });
+
+      if (edits.length === 0) return null;
+
+      return documentChanges(sourceCode, edits);
+    };
+  }
+
+  private getSectionTagChanges(oldSectionName: string, newSectionName: 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 !== 'section') return;
+          if (typeof node.markup === 'string') return;
+
+          // Note the type assertion to the LHS of the expression.
+          // The type assertions above are enough for this to be true.
+          // But I'm making the explicit annotation here to make it clear.
+          const typeNode: LiquidString = node.markup;
+          if (typeNode.value !== oldSectionName) return;
+
+          return {
+            annotationId,
+            newText: newSectionName,
+            range: Range.create(
+              textDocument.positionAt(typeNode.position.start + 1),
+              textDocument.positionAt(typeNode.position.end - 1),
+            ),
+          };
+        },
+      });
+
+      if (edits.length === 0) return null;
+
+      return documentChanges(sourceCode, 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/utils.ts

@@ -0,0 +1,22 @@
+import { Template } from '@platformos/platformos-check-common';
+
+// this is very very optimistic...
+export function isValidTemplate(parsed: unknown): parsed is Template.Template {
+  return (
+    typeof parsed === 'object' &&
+    parsed !== null &&
+    'sections' in parsed &&
+    'order' in parsed &&
+    Array.isArray((parsed as Template.Template).order)
+  );
+}
+
+export function isValidSectionGroup(parsed: unknown): parsed is Template.SectionGroup {
+  return (
+    typeof parsed === 'object' &&
+    parsed !== null &&
+    'sections' in parsed &&
+    'order' in parsed &&
+    Array.isArray((parsed as Template.SectionGroup).order)
+  );
+}

package/src/server/CachedFileSystem.ts

@@ -0,0 +1,39 @@
+import { AbstractFileSystem } from '@platformos/platformos-common';
+
+export class CachedFileSystem implements AbstractFileSystem {
+  readFile: Cached<AbstractFileSystem['readFile']>;
+  readDirectory: Cached<AbstractFileSystem['readDirectory']>;
+  stat: Cached<AbstractFileSystem['stat']>;
+
+  constructor(fs: AbstractFileSystem) {
+    this.readFile = cachedByUri(fs.readFile.bind(fs));
+    this.readDirectory = cachedByUri(fs.readDirectory.bind(fs));
+    this.stat = cachedByUri(fs.stat.bind(fs));
+  }
+}
+
+interface Cached<Fn extends (uri: string) => Promise<any>, T = ReturnType<Fn>> {
+  (uri: string): T;
+  invalidate(uri: string): void;
+}
+
+function cachedByUri<T>(fn: (uri: string) => Promise<T>): Cached<typeof fn> {
+  const cache = new Map<string, Promise<T>>();
+
+  function cached(uri: string) {
+    if (!cache.has(uri)) {
+      // I'm intentionally leaving this comment here for debugging purposes :)
+      // console.error('cache miss', fn.name, uri);
+      cache.set(uri, fn(uri));
+    }
+    return cache.get(uri)!;
+  }
+
+  cached.invalidate = (uri: string) => {
+    // I'm intentionally leaving this comment here for debugging purposes :)
+    // console.error('cache invalidate', fn.name, uri);
+    cache.delete(uri);
+  };
+
+  return cached;
+}

package/src/server/Configuration.ts

@@ -0,0 +1,89 @@
+import { memo } from '@platformos/platformos-check-common';
+import {
+  Connection,
+  DidChangeConfigurationNotification,
+  DidChangeWatchedFilesNotification,
+  DidChangeWatchedFilesRegistrationOptions,
+} from 'vscode-languageserver';
+import { ClientCapabilities } from '../ClientCapabilities';
+
+export const CHECK_ON_OPEN = 'themeCheck.checkOnOpen' as const;
+export const CHECK_ON_SAVE = 'themeCheck.checkOnSave' as const;
+export const CHECK_ON_CHANGE = 'themeCheck.checkOnChange' as const;
+export const PRELOAD_ON_BOOT = 'themeCheck.preloadOnBoot' as const;
+export const ConfigurationKeys = [
+  CHECK_ON_OPEN,
+  CHECK_ON_SAVE,
+  CHECK_ON_CHANGE,
+  PRELOAD_ON_BOOT,
+] as const;
+
+export class Configuration {
+  [CHECK_ON_OPEN]: boolean = true;
+  [CHECK_ON_SAVE]: boolean = true;
+  [CHECK_ON_CHANGE]: boolean = true;
+  [PRELOAD_ON_BOOT]: boolean = true;
+
+  constructor(private connection: Connection, private capabilities: ClientCapabilities) {
+    this.connection = connection;
+    this.capabilities = capabilities;
+  }
+
+  setup() {
+    this[CHECK_ON_OPEN] = this.capabilities.initializationOption(CHECK_ON_OPEN, true);
+    this[CHECK_ON_SAVE] = this.capabilities.initializationOption(CHECK_ON_SAVE, true);
+    this[CHECK_ON_CHANGE] = this.capabilities.initializationOption(CHECK_ON_CHANGE, true);
+    this[PRELOAD_ON_BOOT] = this.capabilities.initializationOption(PRELOAD_ON_BOOT, true);
+  }
+
+  async shouldCheckOnOpen() {
+    await this.fetchConfiguration();
+    return this[CHECK_ON_OPEN];
+  }
+
+  async shouldCheckOnSave() {
+    await this.fetchConfiguration();
+    return this[CHECK_ON_SAVE];
+  }
+
+  async shouldCheckOnChange() {
+    await this.fetchConfiguration();
+    return this[CHECK_ON_CHANGE];
+  }
+
+  async shouldPreloadOnBoot() {
+    await this.fetchConfiguration();
+    return this[PRELOAD_ON_BOOT];
+  }
+
+  clearCache() {
+    this.fetchConfiguration.clearCache();
+  }
+
+  fetchConfiguration = memo(async () => {
+    if (!this.capabilities.hasWorkspaceConfigurationSupport) return;
+
+    const configs = await this.connection.workspace.getConfiguration(
+      ConfigurationKeys.map((key) => ({ section: key })),
+    );
+
+    for (let i = 0; i < ConfigurationKeys.length; i++) {
+      const key = ConfigurationKeys[i];
+      if (configs[i] !== null) {
+        this[key] = configs[i];
+      }
+    }
+  });
+
+  registerDidChangeCapability = memo(async () => {
+    if (!this.capabilities.hasDidChangeConfigurationDynamicRegistrationSupport) return;
+    return this.connection.client.register(DidChangeConfigurationNotification.type);
+  });
+
+  registerDidChangeWatchedFilesNotification = async (
+    options?: DidChangeWatchedFilesRegistrationOptions,
+  ) => {
+    if (!this.capabilities.hasDidChangeWatchedFilesDynamicRegistrationSupport) return;
+    return this.connection.client.register(DidChangeWatchedFilesNotification.type, options);
+  };
+}