@platformos/platformos-language-server-common 0.0.2

package/src/hover/providers/LiquidFilterArgumentHoverProvider.spec.ts

@@ -0,0 +1,57 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+describe('Module: LiquidFilterArgumentHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(async () => {
+    provider = new HoverProvider(
+      new DocumentManager(),
+      {
+        graphQL: async () => null,
+        filters: async () => [
+          {
+            name: 'image_url',
+            syntax: 'string | image_url',
+            description: 'image_url description',
+            parameters: [
+              {
+                name: 'width',
+                description: 'width description',
+                types: ['number'],
+                positional: false,
+                required: false,
+              },
+            ],
+            return_type: [{ type: 'string', name: '' }],
+          },
+        ],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [],
+        systemTranslations: async () => ({}),
+      },
+      new TranslationProvider(new MockFileSystem({})),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    );
+  });
+
+  it('should return nothing if the filter is unknown', async () => {
+    await expect(provider).to.hover(`{{ foo | not_a_filter: wid█th: 1000 }}`, null);
+  });
+
+  it('should return nothing if the parameter is unknown', async () => {
+    await expect(provider).to.hover(`{{ foo | image_url: pig█eons: 1000 }}`, null);
+  });
+
+  it('should return the hover description of parameter', async () => {
+    await expect(provider).to.hover(
+      `{{ foo | image_url: wid█th: 1000 }}`,
+      '### width\nwidth description\n\n---\n\n[platformOS Reference](https://documentation.platformos.com/api-reference/liquid/filters#width)',
+    );
+  });
+});

package/src/hover/providers/LiquidFilterArgumentHoverProvider.ts

@@ -0,0 +1,42 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode, ThemeDocset } from '@platformos/platformos-check-common';
+import { Hover } from 'vscode-languageserver';
+import { render } from '../../docset';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+
+export class LiquidFilterArgumentHoverProvider implements BaseHoverProvider {
+  constructor(private themeDocset: ThemeDocset) {}
+
+  async hover(currentNode: LiquidHtmlNode, ancestors: LiquidHtmlNode[]): Promise<Hover | null> {
+    const parentNode = ancestors.at(-1);
+
+    if (
+      !parentNode ||
+      parentNode.type !== NodeTypes.LiquidFilter ||
+      currentNode.type !== NodeTypes.NamedArgument
+    ) {
+      return null;
+    }
+
+    const parentName = parentNode.name;
+    const entries = await this.themeDocset.filters();
+    const entry = entries.find((entry) => entry.name === parentName);
+
+    if (!entry) {
+      return null;
+    }
+
+    const argument = entry.parameters?.find((argument) => argument.name === currentNode.name);
+
+    if (!argument) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: render(argument, undefined, 'filter'),
+      },
+    };
+  }
+}

package/src/hover/providers/LiquidFilterHoverProvider.spec.ts

@@ -0,0 +1,50 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+describe('Module: LiquidFilterHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(async () => {
+    provider = new HoverProvider(
+      new DocumentManager(),
+      {
+        graphQL: async () => null,
+        filters: async () => [
+          {
+            name: 'upcase',
+            syntax: 'string | upcase',
+            description: 'upcase description',
+            return_type: [{ type: 'string', name: '' }],
+          },
+        ],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [],
+        systemTranslations: async () => ({}),
+      },
+      new TranslationProvider(new MockFileSystem({})),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    );
+  });
+
+  it('should return the hover description of the object', async () => {
+    const contexts = [
+      '{{ foo | upc█ase }}',
+      '{{ foo | upcase█ }}',
+      '{% echo foo | upcase█ %}',
+      '{% liquid\n echo foo | upcase█ %}',
+    ];
+    for (const context of contexts) {
+      await expect(provider).to.hover(context, expect.stringMatching(/##* upcase+: `string`/));
+      await expect(provider).to.hover(context, expect.stringContaining('upcase description'));
+    }
+  });
+
+  it('should return nothing if the thing is unknown', async () => {
+    await expect(provider).to.hover(`{{ foo | unknown█ }}`, null);
+  });
+});

package/src/hover/providers/LiquidFilterHoverProvider.ts

@@ -0,0 +1,29 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode, ThemeDocset } from '@platformos/platformos-check-common';
+import { Hover } from 'vscode-languageserver';
+import { render } from '../../docset';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+
+export class LiquidFilterHoverProvider implements BaseHoverProvider {
+  constructor(private themeDocset: ThemeDocset) {}
+
+  async hover(currentNode: LiquidHtmlNode): Promise<Hover | null> {
+    if (currentNode.type !== NodeTypes.LiquidFilter) {
+      return null;
+    }
+
+    const name = currentNode.name;
+    const entries = await this.themeDocset.filters();
+    const entry = entries.find((entry) => entry.name === name);
+    if (!entry) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: render(entry, undefined, 'filter'),
+      },
+    };
+  }
+}

package/src/hover/providers/LiquidObjectAttributeHoverProvider.spec.ts

@@ -0,0 +1,238 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap, ObjectEntry } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+describe('Module: LiquidObjectAttributeHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(async () => {
+    const _objects: ObjectEntry[] = [
+      {
+        name: 'product',
+        description: 'product description',
+        return_type: [],
+        properties: [
+          {
+            name: 'featured_image',
+            description: 'featured_image description',
+            return_type: [{ type: 'image', name: '' }],
+          },
+          {
+            name: 'images',
+            description: 'images description',
+            return_type: [{ type: 'array', array_value: 'image' }],
+          },
+          {
+            name: 'title',
+            return_type: [{ type: 'string', name: '' }],
+          },
+        ],
+      },
+      {
+        name: 'image',
+        description: 'description of the image type',
+        properties: [
+          {
+            name: 'height',
+            description: 'height description',
+            return_type: [{ type: 'number', name: '' }],
+          },
+        ],
+        access: {
+          global: false,
+          parents: [],
+          template: [],
+        },
+      },
+    ];
+
+    provider = new HoverProvider(
+      new DocumentManager(),
+      {
+        graphQL: async () => null,
+        filters: async () => [],
+        objects: async () => _objects,
+        liquidDrops: async () => _objects,
+        tags: async () => [],
+        systemTranslations: async () => ({}),
+      },
+      new TranslationProvider(new MockFileSystem({})),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    );
+  });
+
+  it('should return the hover description of the object property', async () => {
+    const contexts = [
+      '{{ product.feat█ured_image }}',
+      '{{ product.featured_image█ }}',
+      '{% echo product.featured_image█ %}',
+      '{% liquid\n echo product.featured_image█ %}',
+    ];
+    for (const context of contexts) {
+      await expect(provider).to.hover(
+        context,
+        expect.stringContaining('featured_image description'),
+      );
+      await expect(provider).to.hover(
+        context,
+        expect.stringMatching(/##* featured_image: `image`/),
+      );
+    }
+  });
+
+  describe('when hovering over an array built-in method', () => {
+    it('should return the hover description of the object property', async () => {
+      const contexts = [
+        '{{ product.images.█first }}',
+        '{{ product.images.first█ }}',
+        '{{ product.images.last█ }}',
+        '{% echo product.images.first█ %}',
+      ];
+      for (const context of contexts) {
+        await expect(provider).to.hover(
+          context,
+          expect.stringMatching(/##* (first|last): `image`/),
+        );
+        await expect(provider, context).to.hover(
+          context,
+          expect.stringContaining('description of the image type'),
+        );
+      }
+    });
+
+    it('should return not arbitrarily return the type of the last property', async () => {
+      await expect(provider).to.hover(
+        '{{ product.images.first█.height }}',
+        expect.stringMatching(/##* first: `image`/),
+      );
+      await expect(provider).to.hover(
+        '{{ product.images.firs█t.height }}',
+        expect.stringMatching(/##* first: `image`/),
+      );
+    });
+
+    it('should return the hover description number properties', async () => {
+      const contexts = ['{{ product.images.size█ }}', '{% echo product.images.size█ %}'];
+      for (const context of contexts) {
+        await expect(provider).to.hover(context, expect.stringMatching(/##* size: `number`/));
+      }
+    });
+
+    it('should return nothing if there are no docs for that attribute', async () => {
+      const contexts = ['{{ product.images.length█ }}', '{% echo product.images.length█ %}'];
+      for (const context of contexts) {
+        await expect(provider).to.hover(context, null);
+      }
+    });
+  });
+
+  describe('when hovering over built-in methods of built-in types', () => {
+    it('should return info for size', async () => {
+      const contexts = [
+        '{{ product.title.size█ }}',
+        '{{ product.title.first.size█ }}',
+        '{% echo product.title.size█ %}',
+      ];
+      for (const context of contexts) {
+        await expect(provider).to.hover(context, expect.stringMatching(/##* size: `number`/));
+      }
+    });
+
+    it('should return info for first/last of strings', async () => {
+      const contexts = [
+        '{{ product.title.last█ }}',
+        '{{ product.title.first█ }}',
+        '{{ product.title.first.first█ }}',
+        '{% echo product.title.first█ %}',
+      ];
+      for (const context of contexts) {
+        await expect(provider).to.hover(
+          context,
+          expect.stringMatching(/##* (first|last): `string`/),
+        );
+      }
+    });
+
+    it('should return nothing for unknown attributes of built-ins', async () => {
+      const contexts = ['{{ product.title.length█ }}', '{% echo product.title.unknown█ %}'];
+      for (const context of contexts) {
+        await expect(provider).to.hover(context, null);
+      }
+    });
+  });
+
+  describe('when the parent is untyped', () => {
+    it('should show a hover window (it is like any of any)', async () => {
+      await expect(provider).to.hover(
+        `{% assign x = product.foo %}
+         {{ x.bar█ }}`,
+        expect.stringMatching(/##* bar: `untyped`/),
+      );
+    });
+  });
+
+  it('should return nothing if there are no docs for that attribute', async () => {
+    await expect(provider).to.hover(`{{ product.featured_foo█ }}`, null);
+  });
+
+  describe('when hovering over parse_json variables', () => {
+    it('should return type info for object properties', async () => {
+      await expect(provider).to.hover(
+        `{% assign a = '{"name": "test", "count": 5}' | parse_json %}
+         {{ a.name█ }}`,
+        expect.stringMatching(/##* name: `string`/),
+      );
+    });
+
+    it('should return type info for nested object properties', async () => {
+      await expect(provider).to.hover(
+        `{% assign a = '{"user": {"id": 1, "name": "test"}}' | parse_json %}
+         {{ a.user█ }}`,
+        expect.stringMatching(/##* user: `object`/),
+      );
+      await expect(provider).to.hover(
+        `{% assign a = '{"user": {"id": 1, "name": "test"}}' | parse_json %}
+         {{ a.user█ }}`,
+        expect.stringContaining('Keys: id, name'),
+      );
+    });
+
+    it('should return type info for array properties', async () => {
+      await expect(provider).to.hover(
+        `{% assign a = '{"items": [1, 2, 3]}' | parse_json %}
+         {{ a.items█ }}`,
+        expect.stringMatching(/##* items: `number\[\]`/),
+      );
+    });
+
+    it('should return type info for nested array properties', async () => {
+      await expect(provider).to.hover(
+        `{% assign a = '[{"name": "test"}]' | parse_json %}
+         {{ a.first█ }}`,
+        expect.stringMatching(/##* first: `object`/),
+      );
+    });
+
+    it('should return type info for parse_json block syntax', async () => {
+      await expect(provider).to.hover(
+        `{% parse_json data %}
+           {"status": "active", "count": 5}
+         {% endparse_json %}
+         {{ data.status█ }}`,
+        expect.stringMatching(/##* status: `string`/),
+      );
+    });
+
+    it('should return type info for hash_assign with parse_json value', async () => {
+      await expect(provider).to.hover(
+        `{% assign a = '{}' | parse_json %}
+         {% hash_assign a['nested'] = '{"deep": "value"}' | parse_json %}
+         {{ a.nested█ }}`,
+        expect.stringMatching(/##* nested: `object`/),
+      );
+    });
+  });
+});

package/src/hover/providers/LiquidObjectAttributeHoverProvider.ts

@@ -0,0 +1,156 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode } from '@platformos/platformos-check-common';
+import { Hover, HoverParams } from 'vscode-languageserver';
+import {
+  TypeSystem,
+  Unknown,
+  Untyped,
+  isArrayType,
+  isShapeType,
+  isUnionType,
+  typeToDisplayString,
+} from '../../TypeSystem';
+import { shapeToTypeString, shapeToDetailString } from '../../PropertyShapeInference';
+import { render } from '../../docset';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+
+export class LiquidObjectAttributeHoverProvider implements BaseHoverProvider {
+  constructor(private typeSystem: TypeSystem) {}
+
+  async hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null> {
+    const parentNode = ancestors.at(-1);
+    const uri = params.textDocument.uri;
+    if (
+      currentNode.type !== NodeTypes.String ||
+      !parentNode ||
+      parentNode.type !== NodeTypes.VariableLookup ||
+      !parentNode.lookups.includes(currentNode)
+    ) {
+      return null;
+    }
+
+    const lookupIndex = parentNode.lookups.findIndex((lookup) => lookup === currentNode);
+    const node = {
+      ...parentNode,
+      lookups: parentNode.lookups.slice(0, lookupIndex),
+    };
+
+    const objectMap = await this.typeSystem.objectMap(uri, ancestors[0]);
+    const parentType = await this.typeSystem.inferType(node, ancestors[0], uri);
+
+    // Handle ShapeType from parse_json, graphql, hash_assign
+    if (isShapeType(parentType)) {
+      const nodeType = await this.typeSystem.inferType(
+        { ...parentNode, lookups: parentNode.lookups.slice(0, lookupIndex + 1) },
+        ancestors[0],
+        uri,
+      );
+
+      // Return hover info for shape types
+      if (isShapeType(nodeType)) {
+        return {
+          contents: {
+            kind: 'markdown',
+            value: `### ${currentNode.value}: \`${shapeToTypeString(
+              nodeType.shape,
+            )}\`\n${shapeToDetailString(nodeType.shape)}`,
+          },
+        };
+      }
+
+      // Handle primitive types from shape lookup
+      if (nodeType !== Unknown && nodeType !== Untyped && !isArrayType(nodeType)) {
+        return {
+          contents: {
+            kind: 'markdown',
+            value: `### ${currentNode.value}: \`${nodeType}\``,
+          },
+        };
+      }
+
+      if (nodeType === Unknown) return null;
+
+      return {
+        contents: {
+          kind: 'markdown',
+          value: `### ${currentNode.value}: \`${
+            isArrayType(nodeType) ? `${nodeType.valueType}[]` : nodeType
+          }\``,
+        },
+      };
+    }
+
+    if (
+      isArrayType(parentType) ||
+      parentType === 'string' ||
+      parentType === Untyped ||
+      isUnionType(parentType)
+    ) {
+      const nodeType = await this.typeSystem.inferType(
+        { ...parentNode, lookups: parentNode.lookups.slice(0, lookupIndex + 1) },
+        ancestors[0],
+        uri,
+      );
+
+      // 2D arrays, unknown types and shape types are handled differently
+      if (isArrayType(nodeType) || nodeType === Unknown) return null;
+
+      if (isShapeType(nodeType)) {
+        return {
+          contents: {
+            kind: 'markdown',
+            value: `### ${currentNode.value}: \`${shapeToTypeString(
+              nodeType.shape,
+            )}\`\n${shapeToDetailString(nodeType.shape)}`,
+          },
+        };
+      }
+
+      if (isUnionType(nodeType)) {
+        return {
+          contents: {
+            kind: 'markdown',
+            value: `### ${currentNode.value}: \`${typeToDisplayString(nodeType)}\``,
+          },
+        };
+      }
+
+      // We want want `## first: `nodeType` with the docs of the nodeType
+      const entry = { ...(objectMap[nodeType] ?? {}), name: currentNode.value };
+
+      return {
+        contents: {
+          kind: 'markdown',
+          value: render(entry, nodeType),
+        },
+      };
+    }
+
+    // UnionType doesn't have properties, so return null if it reaches here
+    if (isUnionType(parentType)) {
+      return null;
+    }
+
+    const parentEntry = objectMap[parentType];
+    if (!parentEntry) {
+      return null;
+    }
+
+    const parentTypeProperties = objectMap[parentType]?.properties || [];
+    const entry = parentTypeProperties.find((p: { name: string }) => p.name === currentNode.value);
+    if (!entry) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: render(entry),
+      },
+    };
+  }
+}