@platformos/platformos-language-server-common 0.0.2

package/src/settings/index.ts

@@ -0,0 +1,50 @@
+export type GetThemeSettingsSchemaForURI = (uri: string) => Promise<SettingsSchemaJSONFile>;
+
+export type SettingsSchemaJSONFile = (ThemeInfo | SettingsCategory)[];
+
+export interface ThemeInfo {
+  name: string;
+  theme_name: string;
+  theme_author: string;
+  theme_version: string;
+  theme_documentation_url: string;
+  theme_support_url?: string;
+  theme_support_email?: string;
+}
+
+export interface SettingsCategory {
+  name: string;
+  settings: Setting[];
+}
+
+export type Setting = SideBarSetting | InputSetting;
+
+export interface SideBarSetting {
+  type: string;
+  content: string;
+}
+
+export interface InputSetting {
+  type: string;
+  id: string;
+  label: string;
+  default?: number | string | boolean | string[];
+  info?: string;
+}
+
+interface Option {
+  label: string;
+  value: string;
+}
+
+interface MaybeGroupedOption extends Option {
+  group?: string;
+}
+
+export function isSettingsCategory(x: ThemeInfo | SettingsCategory): x is SettingsCategory {
+  return 'settings' in x;
+}
+
+export function isInputSetting(x: Setting): x is InputSetting {
+  return 'id' in x && 'type' in x && 'label' in x;
+}

package/src/test/ApplyEditsAssertion.spec.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from 'vitest';
+import { Range, TextEdit } from 'vscode-languageserver-protocol';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+describe('Module: ApplyTextEditAssertion', () => {
+  const source = 'hello world';
+  const textDocument = TextDocument.create('file:///file.liquid', 'liquid', 1, source);
+  const indexOfHello = source.indexOf('hello');
+  const helloToHiEdit = TextEdit.replace(
+    Range.create(
+      textDocument.positionAt(indexOfHello),
+      textDocument.positionAt(indexOfHello + 'hello'.length),
+    ),
+    'hi',
+  );
+  const indexOfWorld = source.indexOf('world');
+  const worldToPlanetEdit = TextEdit.replace(
+    Range.create(
+      textDocument.positionAt(indexOfWorld),
+      textDocument.positionAt(indexOfWorld + 'world'.length),
+    ),
+    'planet',
+  );
+
+  it('should do normal matching as expected', () => {
+    expect(worldToPlanetEdit).to.applyEdits(source, 'hello planet');
+    expect(worldToPlanetEdit).not.to.applyEdits('super world', 'hello planet');
+  });
+
+  it('should accept arrays of text edits', () => {
+    expect([helloToHiEdit, worldToPlanetEdit]).to.applyEdits(source, 'hi planet');
+    expect([helloToHiEdit, worldToPlanetEdit]).not.to.applyEdits(source, 'something else entirely');
+  });
+
+  it('should strip the █ character from source strings', () => {
+    expect(helloToHiEdit).to.applyEdits('hello █world', 'hi world');
+  });
+
+  it('should accept text document objects as source replacements', () => {
+    expect(helloToHiEdit).to.applyEdits(textDocument, 'hi world');
+  });
+
+  it('should support asymmetric matching', () => {
+    const actual = { label: 'foo', textEdit: worldToPlanetEdit };
+    expect(actual).toEqual(
+      expect.objectContaining({
+        textEdit: expect.applyEdits(source, 'hello planet'),
+      }),
+    );
+
+    expect(actual).not.toEqual(
+      expect.objectContaining({
+        textEdit: expect.applyEdits('super world', 'hello planet'),
+      }),
+    );
+  });
+});

package/src/test/ApplyEditsAssertion.ts

@@ -0,0 +1,34 @@
+import { RawMatcherFn } from '@vitest/expect';
+import { TextEdit } from 'vscode-languageserver-protocol';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+
+interface CustomMatchers<R = unknown> {
+  applyEdits: (source: string | TextDocument, expected: string) => R;
+}
+
+declare module 'vitest' {
+  interface Assertion<T = any> extends CustomMatchers<TextEdit | TextEdit[]> {}
+  interface AsymmetricMatchersContaining extends CustomMatchers {}
+}
+
+export const applyEdits: RawMatcherFn = (
+  received: TextEdit | TextEdit[],
+  source: TextDocument | string,
+  expected: string,
+) => {
+  const textDocument =
+    typeof source === 'string'
+      ? TextDocument.create('file:///file.liquid', 'liquid', 1, source.replace('█', ''))
+      : source;
+  const actual = TextDocument.applyEdits(
+    textDocument,
+    Array.isArray(received) ? received : [received],
+  );
+  return {
+    message: () => `expected following edit[1] to change source[2] to equal expected[3]
+[1]: ${JSON.stringify(received, null, 2)}
+[2]: ${textDocument.getText()}
+[3]: ${expected}`,
+    pass: actual === expected,
+  };
+};

package/src/test/CompletionItemsAssertion.spec.ts

@@ -0,0 +1,48 @@
+import { expect, describe, it, beforeEach } from 'vitest';
+import { CompletionsProvider } from '../completions';
+import { DocumentManager } from '../documents';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+
+describe('Module: CompletionItemsAssertion', () => {
+  let provider: CompletionsProvider;
+  let documentManager: DocumentManager;
+
+  beforeEach(async () => {
+    documentManager = new DocumentManager();
+    provider = new CompletionsProvider({
+      documentManager,
+      themeDocset: {
+        graphQL: async () => null,
+        filters: async () => [],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [{ name: 'render' }],
+        systemTranslations: async () => ({}),
+      },
+      getMetafieldDefinitions: async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    });
+  });
+
+  it('should assert a list of labels', async () => {
+    await expect(provider).to.complete('{% rend', ['render']);
+  });
+
+  it('should assert a list of completion items', async () => {
+    await expect(provider).to.complete('{% rend', [
+      expect.objectContaining({
+        label: 'render',
+        sortText: 'render',
+        documentation: {
+          kind: 'markdown',
+          value: '### render',
+        },
+        insertTextFormat: 2,
+        kind: 14,
+      }),
+    ]);
+  });
+
+  it('should assert an empty list', async () => {
+    await expect(provider).to.complete('{% something', []);
+  });
+});

package/src/test/CompletionItemsAssertion.ts

@@ -0,0 +1,99 @@
+import { CompletionItem, Position } from 'vscode-languageserver-protocol';
+import { CompletionsProvider } from '../completions';
+import { expect } from 'vitest';
+import { AsyncExpectationResult, MatcherState, RawMatcherFn } from '@vitest/expect';
+
+export type CompleteContext = { relativePath: string; source: string };
+
+interface CustomMatchers<R = unknown> {
+  /**
+   * @param source {string | CompleteContext} - the source to complete
+   * @param completionItem {CompletionItem[] | string[]} - the list of completion items or labels
+   *
+   * @example
+   * expect(provider).to.complete("{% end", ["endcomment"])
+   * expect(provider).to.complete({ source: "{% end", relativePath: 'sections/foo.liquid' }, ["endcomment"])
+   */
+  complete(
+    source: string | CompleteContext,
+    completionItem: Partial<CompletionItem>[] | string[],
+  ): Promise<void>;
+}
+
+declare module 'vitest' {
+  interface Assertion<T = any> extends CustomMatchers<T> {}
+  interface AsymmetricMatchersContaining extends CustomMatchers {}
+}
+
+export const complete: RawMatcherFn<MatcherState> = async function (
+  this: MatcherState,
+  provider: CompletionsProvider,
+  context: string | CompleteContext,
+  expected: any[] | ReturnType<typeof expect.arrayContaining>,
+): AsyncExpectationResult {
+  const { isNot, equals, utils } = this;
+  const completeContext = asCompleteContextObject(context);
+  const source = createSourceCode(completeContext);
+  const completionParams = createCompletionParams(completeContext);
+  provider.documentManager.open(completionParams.textDocument.uri, source, 1);
+  const result = await provider.completions(completionParams);
+
+  let pass = false;
+  if ('asymmetricMatch' in expected) {
+    pass = equals(result, expected);
+  } else if (Array.isArray(expected)) {
+    pass =
+      result.length === expected.length &&
+      expected.every((expectation, i) =>
+        equals(
+          result[i],
+          typeof expectation === 'string'
+            ? expect.objectContaining({
+                label: expectation,
+              })
+            : expectation,
+        ),
+      );
+  } else {
+    throw new Error('Expecting array or expect.arrayContaining');
+  }
+
+  return {
+    pass,
+    message: () =>
+      `expected complete to${isNot ? ' not' : ''} match value ${utils.printExpected(
+        expected,
+      )}\ncontext:\n${context}`,
+    actual: result,
+    expected: expected,
+  };
+};
+
+function asCompleteContextObject(context: string | CompleteContext): CompleteContext {
+  if (typeof context === 'string') return { source: context, relativePath: 'file.liquid' };
+  return context;
+}
+
+function createSourceCode(context: CompleteContext) {
+  const regex = new RegExp('█', 'g');
+  return context.source.replace(regex, '');
+}
+
+function createCompletionParams(context: CompleteContext) {
+  const position = createPosition(context.source);
+  const textDocument = { uri: `/path/to/${context.relativePath}` };
+
+  return {
+    position,
+    textDocument,
+  };
+}
+
+function createPosition(context: string): Position {
+  const index = context.indexOf('█');
+  const lines = context.substring(0, index === -1 ? context.length : index).split('\n');
+  const line = lines.length - 1;
+  const character = lines[line].length;
+
+  return { line, character };
+}

package/src/test/HoverAssertion.ts

@@ -0,0 +1,84 @@
+import { expect } from 'vitest';
+import { AsyncExpectationResult, MatcherState, RawMatcherFn } from '@vitest/expect';
+import { HoverParams, MarkupContent } from 'vscode-languageserver-protocol';
+import { HoverProvider } from '../hover';
+
+interface CustomMatchers<R = unknown> {
+  hover(context: string | HoverContext, expected: null | string): Promise<R>;
+}
+
+export type HoverContext = {
+  source: string;
+  relativePath: string;
+};
+
+declare module 'vitest' {
+  interface Assertion<T = any> extends CustomMatchers<T> {}
+  interface AsymmetricMatchersContaining extends CustomMatchers {}
+}
+
+export const hover: RawMatcherFn<MatcherState> = async function (
+  this: MatcherState,
+  provider: HoverProvider,
+  context: string | HoverContext,
+  expected: any,
+): AsyncExpectationResult {
+  const { isNot, equals, utils } = this;
+  const hoverContext = asHoverContext(context);
+  const { source, relativePath } = hoverContext;
+
+  const { documentManager } = provider;
+  const cursorPosition = source.indexOf('█');
+
+  if (cursorPosition === -1) {
+    return {
+      pass: false,
+      message: () => 'Expected to find "█" in context string to represent cursor position',
+    };
+  }
+
+  const textDocumentUri = `file:///${relativePath}`;
+  documentManager.open(textDocumentUri, source.replace(/█/g, ''), 0);
+  const textDocument = documentManager.get(textDocumentUri)!.textDocument;
+  const params: HoverParams = {
+    position: textDocument.positionAt(cursorPosition),
+    textDocument: {
+      uri: textDocumentUri,
+    },
+  };
+
+  const result = await provider.hover(params);
+
+  const isExpectingNull = expected === null;
+  if (isExpectingNull) {
+    return {
+      pass: result === expected,
+      message: () => `expected hover to ${isNot ? 'not ' : ''}be null`,
+      actual: result,
+      expected: expected,
+    };
+  }
+
+  return {
+    pass: equals(
+      result,
+      expect.objectContaining({
+        contents: {
+          kind: 'markdown',
+          value: expected,
+        },
+      }),
+    ),
+    message: () =>
+      `expected hover to${isNot ? ' not' : ''} match value ${utils.printExpected(
+        expected,
+      )}\ncontext:\n${context}`,
+    actual: result === null ? result : (result.contents as MarkupContent).value,
+    expected: expected,
+  };
+};
+
+function asHoverContext(context: string | HoverContext): HoverContext {
+  if (typeof context === 'string') return { source: context, relativePath: 'app/file.liquid' };
+  return context;
+}

package/src/test/MockChecks.ts

@@ -0,0 +1,32 @@
+import {
+  LiquidCheckDefinition,
+  Severity,
+  SourceCodeType,
+} from '@platformos/platformos-check-common';
+
+export const LiquidFilter: LiquidCheckDefinition = {
+  meta: {
+    code: 'LiquidFilter',
+    name: 'Complains about every LiquidFilter',
+    docs: {
+      description: 'Complains about every LiquidFilter',
+      recommended: true,
+    },
+    type: SourceCodeType.LiquidHtml,
+    severity: Severity.ERROR,
+    schema: {},
+    targets: [],
+  },
+
+  create(context) {
+    return {
+      LiquidFilter: async (node) => {
+        context.report({
+          message: 'Liquid filter can not be used',
+          startIndex: node.position.start,
+          endIndex: node.position.end,
+        });
+      },
+    };
+  },
+};

package/src/test/MockConnection.ts

@@ -0,0 +1,158 @@
+import { vi } from 'vitest';
+import { EventEmitter } from 'node:events';
+import { createConnection } from 'vscode-languageserver/lib/common/server';
+import {
+  ClientCapabilities,
+  DidChangeTextDocumentNotification,
+  DidCloseTextDocumentNotification,
+  DidOpenTextDocumentNotification,
+  DidSaveTextDocumentNotification,
+  InitializedNotification,
+  InitializeParams,
+  InitializeRequest,
+  MessageSignature,
+  ProtocolConnection,
+  WatchDog,
+} from 'vscode-languageserver';
+import { path } from '@platformos/platformos-check-common';
+
+type MockConnectionMethods = {
+  /** Trigger all appropriate onNotification handlers on the connection */
+  triggerNotification: ReturnType<typeof createConnection>['sendNotification'];
+
+  /** Trigger all appropriate onRequest handlers on the connection */
+  triggerRequest: ReturnType<typeof createConnection>['sendRequest'];
+
+  /** Perform the initialize/initialized lifecycle methods */
+  setup(capabilities?: ClientCapabilities, initializationOptions?: any): void;
+
+  /** Perform the textDocument/didOpen notification */
+  openDocument(relativePath: string, contents: string): void;
+
+  /** Perform the textDocument/didChange notification */
+  changeDocument(relativePath: string, contents: string, version: number): void;
+
+  /** Perform the textDocument/didClose notification */
+  closeDocument(relativePath: string): void;
+
+  /** Perform the textDocument/didSave notification */
+  saveDocument(relativePath: string): void;
+
+  spies: ReturnType<typeof protocolConnection>;
+};
+
+/**
+ * A mock connection behaves like a real connection, except we can trigger
+ * messages manually via the extra MockConnectionMethods.
+ */
+export type MockConnection = ReturnType<typeof createConnection> & MockConnectionMethods;
+
+function protocolConnection(requests: EventEmitter, notifications: EventEmitter) {
+  return {
+    dispose: vi.fn(),
+    end: vi.fn(),
+    hasPendingResponse: vi.fn(),
+    listen: vi.fn(),
+    onClose: vi.fn(),
+    onDispose: vi.fn(),
+    onError: vi.fn(),
+    onProgress: vi.fn(),
+    onNotification: vi.fn().mockImplementation((type: MessageSignature, handler) => {
+      notifications.addListener(type.method, handler);
+    }),
+    onRequest: vi.fn().mockImplementation((type: MessageSignature, handler) => {
+      requests.addListener(type.method, handler);
+    }),
+    onUnhandledNotification: vi.fn(),
+    sendNotification: vi.fn().mockReturnValue(Promise.resolve()),
+    sendProgress: vi.fn(),
+    sendRequest: vi.fn(),
+    trace: vi.fn().mockReturnValue(Promise.resolve()),
+  } satisfies ProtocolConnection;
+}
+
+export function mockConnection(rootUri: string): MockConnection {
+  const watchDog: WatchDog = {
+    exit: vi.fn(),
+    initialize: vi.fn(),
+    shutdownReceived: false,
+  };
+
+  const requests = new EventEmitter();
+  const notifications = new EventEmitter();
+  const spies = protocolConnection(requests, notifications);
+
+  // Create a real "connection" with the fake communication channel
+  const connection = createConnection(() => spies, watchDog);
+
+  // Create a mock way to trigger notification in our tests
+  const triggerNotification: MockConnection['sendNotification'] = async (...args: any[]) => {
+    const [type, params] = args;
+    const method = typeof type === 'string' ? type : type.method;
+    notifications.emit(method, params);
+  };
+
+  // Create a mock way to trigger requests in our tests
+  const triggerRequest: MockConnection['triggerRequest'] = async (...args: any[]) => {
+    const [type, params] = args;
+    const method = typeof type === 'string' ? type : type.method;
+    requests.emit(method, params);
+  };
+
+  const mockConnectionMethods: MockConnectionMethods = {
+    triggerNotification,
+    triggerRequest,
+    spies,
+
+    setup(capabilities: ClientCapabilities = {}, initializationOptions = {}) {
+      triggerRequest(InitializeRequest.method, {
+        capabilities,
+        initializationOptions,
+      } as InitializeParams);
+      triggerNotification(InitializedNotification.method);
+    },
+
+    openDocument(relativePath, text) {
+      triggerNotification(DidOpenTextDocumentNotification.type, {
+        textDocument: {
+          languageId: 'liquid',
+          uri: path.join(rootUri, relativePath),
+          version: 0,
+          text,
+        },
+      });
+    },
+
+    changeDocument(relativePath, text, version) {
+      triggerNotification(DidChangeTextDocumentNotification.type, {
+        textDocument: {
+          uri: path.join(rootUri, relativePath),
+          version,
+        },
+        contentChanges: [
+          {
+            text,
+          },
+        ],
+      });
+    },
+
+    closeDocument(relativePath) {
+      triggerNotification(DidCloseTextDocumentNotification.type, {
+        textDocument: {
+          uri: path.join(rootUri, relativePath),
+        },
+      });
+    },
+
+    saveDocument(relativePath) {
+      triggerNotification(DidSaveTextDocumentNotification.type, {
+        textDocument: {
+          uri: path.join(rootUri, relativePath),
+        },
+      });
+    },
+  };
+
+  return Object.assign(connection, mockConnectionMethods) satisfies MockConnection;
+}

package/src/test/test-setup.ts

@@ -0,0 +1,6 @@
+import { expect } from 'vitest';
+import { applyEdits } from './ApplyEditsAssertion';
+import { complete } from './CompletionItemsAssertion';
+import { hover } from './HoverAssertion';
+
+expect.extend({ hover, complete, applyEdits });

package/src/translations.ts

@@ -0,0 +1,83 @@
+import { Translations } from '@platformos/platformos-check-common';
+
+export type GetTranslationsForURI = (uri: string) => Promise<Translations>;
+export type Translation = string | PluralizedTranslation;
+export type TranslationOption = { path: string[]; translation: Translation };
+
+export const PluralizedTranslationKeys = ['one', 'few', 'many', 'two', 'zero', 'other'] as const;
+export type PluralizedTranslation = {
+  [key in (typeof PluralizedTranslationKeys)[number]]?: string;
+};
+
+export function renderKey(
+  translation: PluralizedTranslation,
+  key: keyof PluralizedTranslation,
+): string | undefined {
+  if (translation[key]) {
+    return `\`${key}:\` ${translation[key]}`;
+  }
+}
+
+export function renderTranslation(translation: string | PluralizedTranslation) {
+  if (typeof translation === 'string') return translation;
+  return [
+    renderKey(translation, 'zero'),
+    renderKey(translation, 'one'),
+    renderKey(translation, 'two'),
+    renderKey(translation, 'few'),
+    renderKey(translation, 'many'),
+    renderKey(translation, 'other'),
+  ]
+    .filter(Boolean)
+    .join('\n\n---\n\n');
+}
+
+export function translationValue(
+  path: string,
+  translations: Translations,
+): undefined | string | PluralizedTranslation {
+  const parts = path.split('.');
+  let current: Translations | string | undefined = translations;
+  for (const key of parts) {
+    if (!current || typeof current === 'string') {
+      return undefined;
+    }
+    current = current[key];
+  }
+  return current;
+}
+
+export function isPluralizedTranslation(
+  translations: Translations,
+): translations is PluralizedTranslation {
+  return Object.keys(translations).every((key) => PluralizedTranslationKeys.includes(key as any));
+}
+
+export function toOptions(prefix: string[], translations: Translations): TranslationOption[] {
+  return Object.entries(translations).flatMap(([path, translation]) => {
+    if (typeof translation === 'string' || isPluralizedTranslation(translation)) {
+      return [{ path: prefix.concat(path), translation }];
+    } else {
+      return toOptions(prefix.concat(path), translation);
+    }
+  });
+}
+
+export function translationOptions(translations: Translations): TranslationOption[] {
+  return toOptions([], translations);
+}
+
+export function extractParams(value: string) {
+  const regex = /\{\{([^}]+?)\}\}/g;
+  const results = [];
+  let current;
+  while ((current = regex.exec(value)) !== null) {
+    results.push(current[1].trim());
+  }
+  return results;
+}
+
+export function paramsString(params: string[]) {
+  if (params.length === 0) return '';
+  return `: ` + params.map((param) => `${param}: ${param}`).join(', ');
+}