@platformos/platformos-language-server-common 0.0.2

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

@@ -0,0 +1,278 @@
+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: LiquidObjectHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(async () => {
+    const _objects: ObjectEntry[] = [
+      {
+        name: 'product',
+        description: 'product description',
+        return_type: [],
+        properties: [
+          {
+            name: 'featured_image',
+            return_type: [{ type: 'image', name: '' }],
+          },
+          {
+            name: 'title',
+            return_type: [{ type: 'string', name: '' }],
+          },
+          { name: 'metafields' },
+        ],
+      },
+      {
+        name: 'all_products',
+        return_type: [{ type: 'array', array_value: 'product' }],
+      },
+      {
+        name: 'paginate',
+        access: { global: false, parents: [], template: [] },
+        return_type: [],
+      },
+      {
+        name: 'forloop',
+        access: { global: false, parents: [], template: [] },
+        return_type: [],
+      },
+      {
+        name: 'tablerowloop',
+        access: { global: false, parents: [], template: [] },
+        return_type: [],
+      },
+      {
+        name: 'image',
+        description: 'image description',
+        access: { global: false, parents: [], template: [] },
+      },
+      {
+        name: 'section',
+        access: { global: false, parents: [], template: [] },
+      },
+      {
+        name: 'block',
+        access: { global: false, parents: [], template: [] },
+      },
+      {
+        name: 'app',
+        access: { global: false, parents: [], template: [] },
+      },
+      {
+        name: 'predictive_search',
+        access: { global: false, parents: [], template: [] },
+      },
+      {
+        name: 'recommendations',
+        access: { global: false, parents: [], template: [] },
+      },
+      {
+        name: 'metafield',
+        access: {
+          global: false,
+          template: [],
+          parents: [],
+        },
+        properties: [
+          {
+            name: 'type',
+            description: 'the type of the metafield',
+            return_type: [{ type: 'string', name: '' }],
+          },
+          {
+            name: 'value',
+            description: 'the value of the metafield',
+            return_type: [{ type: 'untyped', name: '' }],
+          },
+        ],
+      },
+    ];
+
+    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 (_uri: string) => {
+        return {
+          article: [],
+          blog: [],
+          collection: [],
+          company: [],
+          company_location: [],
+          location: [],
+          market: [],
+          order: [],
+          page: [],
+          product: [
+            {
+              key: 'color',
+              name: 'color',
+              namespace: 'custom',
+              description: 'the color of the product',
+              type: {
+                category: 'COLOR',
+                name: 'color',
+              },
+            },
+          ],
+          variant: [],
+          shop: [],
+        } as MetafieldDefinitionMap;
+      },
+    );
+  });
+
+  it('should return the hover description of the object', async () => {
+    const contexts = [
+      '{{ pro█duct }}',
+      '{{ product█ }}',
+      '{% echo product█ %}',
+      '{% liquid\n echo product█ %}',
+      '{% assign x = product %}{{ x█ }}',
+      '{% for x in all_products %}{{ x█ }}{% endfor %}',
+      '{% assign x = all_products[0] %}{{ x█ }}',
+      '{% assign x█ = all_products[0] %}',
+      // '{% for x█ in all_products %}{{ x }}{% endfor %}', // not supported yet...
+    ];
+    for (const context of contexts) {
+      await expect(provider).to.hover(context, expect.stringContaining('product description'));
+      await expect(provider).to.hover(context, expect.stringMatching(/##* \w+: `product`/));
+    }
+  });
+
+  it('should support paginate inside paginate tags', async () => {
+    const context = `
+      {% paginate all_products by 5 %}
+        {{ paginate█ }}
+      {% endpaginate %}
+    `;
+    await expect(provider).to.hover(context, expect.stringMatching(/##* paginate: `paginate`/));
+    await expect(provider).to.hover('{{ paginate█ }}', null);
+  });
+
+  it('should support form inside form tags', async () => {
+    const context = `
+      {% form all_products by 5 %}
+        {{ form█ }}
+      {% endform %}
+    `;
+    await expect(provider).to.hover(context, expect.stringMatching(/##* form: `form`/));
+    await expect(provider).to.hover('{{ form█ }}', null);
+  });
+
+  it('should support forloop inside for tags', async () => {
+    const context = `
+      {% for p in all_products %}
+        {{ forloop█ }}
+      {% endfor %}
+    `;
+    await expect(provider).to.hover(context, expect.stringMatching(/##* forloop: `forloop`/));
+    await expect(provider).to.hover('{{ forloop█ }}', null);
+  });
+
+  it('should support tablerowloop inside tablerow tags', async () => {
+    const context = `
+      {% tablerow p in all_products %}
+        {{ tablerowloop█ }}
+      {% endtablerow %}
+    `;
+    await expect(provider).to.hover(
+      context,
+      expect.stringMatching(/##* tablerowloop: `tablerowloop`/),
+    );
+    await expect(provider).to.hover('{{ tablerowloop█ }}', null);
+  });
+
+  it('should support {% layout none %}', async () => {
+    await expect(provider).to.hover(
+      `{% layout none█ %}`,
+      expect.stringMatching(/##* none: `keyword`/),
+    );
+    await expect(provider).to.hover('{{ none█ }}', null);
+  });
+
+  it('should support {% increment var %}', async () => {
+    await expect(provider).to.hover(
+      `{% increment var█ %}`,
+      expect.stringMatching(/##* var: `number`/),
+    );
+    await expect(provider).to.hover('{{ var█ }}', null);
+  });
+
+  it('should support {% decrement var %}', async () => {
+    await expect(provider).to.hover(
+      `{% decrement var█ %}`,
+      expect.stringMatching(/##* var: `number`/),
+    );
+    await expect(provider).to.hover('{{ var█ }}', null);
+  });
+
+  it('should support contextual objects by relative path', async () => {
+    const contexts: [string, string][] = [
+      ['section', 'sections/my-section.liquid'],
+      ['block', 'blocks/my-block.liquid'],
+      ['predictive_search', 'sections/predictive-search.liquid'],
+      ['recommendations', 'sections/recommendations.liquid'],
+      ['app', 'blocks/recommendations.liquid'],
+      ['app', 'app/views/partials/recommendations.liquid'],
+    ];
+    for (const [object, relativePath] of contexts) {
+      const source = `{{ ${object}█ }}`;
+      await expect(provider).to.hover(
+        { source, relativePath },
+        expect.stringContaining(`## ${object}`),
+      );
+      await expect(provider).to.hover({ source, relativePath: 'file.liquid' }, null);
+    }
+  });
+
+  it('should support metafields', async () => {
+    await expect(provider).to.hover(
+      '{{ product.metafields.custom█ }}',
+      '### custom: `product_metafield_custom`',
+    );
+    await expect(provider).to.hover(
+      '{{ product.metafields.custom.color█ }}',
+      '### color: `metafield_color`\nthe color of the product',
+    );
+  });
+
+  it('should return null when hovering over an undefined variable', async () => {
+    await expect(provider).to.hover(`{{ unknown█ }}`, null);
+  });
+
+  it('should return something if the thing is knowingly untyped', async () => {
+    await expect(provider).to.hover(
+      `{% assign src = product.featured_image.src %}{{ src█ }}`,
+      `### src: \`untyped\``,
+    );
+  });
+
+  it('should still return null when hovering over an unknown variable out of scope', async () => {
+    await expect(provider).to.hover(
+      `{% for p in all_products %}
+        {{ forloop█ }}
+      {% endfor %}
+      {{ forloop }}`,
+      expect.stringMatching(/##* forloop: `forloop`/),
+    );
+    await expect(provider).to.hover(
+      `{% for p in all_products %}
+        {{ forloop }}
+      {% endfor %}
+      {{ forloop█ }}`,
+      null,
+    );
+  });
+});

package/src/hover/providers/LiquidObjectHoverProvider.ts

@@ -0,0 +1,95 @@
+import { LiquidHtmlNode, LiquidVariableLookup, NodeTypes } from '@platformos/liquid-html-parser';
+import { Hover, HoverParams } from 'vscode-languageserver';
+import {
+  TypeSystem,
+  Unknown,
+  Untyped,
+  isArrayType,
+  isShapeType,
+  isUnionType,
+} from '../../TypeSystem';
+import { render } from '../../docset';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+
+export class LiquidObjectHoverProvider implements BaseHoverProvider {
+  constructor(private typeSystem: TypeSystem) {}
+
+  async hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null> {
+    if (
+      currentNode.type !== NodeTypes.VariableLookup &&
+      currentNode.type !== NodeTypes.AssignMarkup
+    ) {
+      return null;
+    }
+
+    if (!currentNode.name) {
+      return null;
+    }
+
+    let node = currentNode;
+    if (node.type === NodeTypes.VariableLookup) {
+      node = {
+        ...currentNode,
+        lookups: [],
+      } as LiquidVariableLookup;
+    }
+
+    const type = await this.typeSystem.inferType(node, ancestors[0], params.textDocument.uri);
+    const objectMap = await this.typeSystem.objectMap(params.textDocument.uri, ancestors[0]);
+
+    if (type === Unknown) {
+      return null;
+    }
+
+    // Handle ShapeType from parse_json, graphql, hash_assign
+    if (isShapeType(type)) {
+      return {
+        contents: {
+          kind: 'markdown',
+          value: render({ name: currentNode.name }, type, 'object'),
+        },
+      };
+    }
+
+    // Handle UnionType from function returns
+    if (isUnionType(type)) {
+      return {
+        contents: {
+          kind: 'markdown',
+          value: render({ name: currentNode.name }, type, 'object'),
+        },
+      };
+    }
+
+    const entryType = isArrayType(type) ? type.valueType : type;
+    const entry = objectMap[entryType];
+
+    if (!entry) {
+      const entryByName = objectMap[currentNode.name] ?? {};
+      return {
+        contents: {
+          kind: 'markdown',
+          value: render(
+            {
+              ...entryByName,
+              name: currentNode.name,
+            },
+            type,
+            'object',
+          ),
+        },
+      };
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: render({ ...entry, name: currentNode.name }, type, 'object'),
+      },
+    };
+  }
+}

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

@@ -0,0 +1,51 @@
+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: LiquidTagHoverProvider', async () => {
+  let provider: HoverProvider;
+
+  beforeEach(async () => {
+    provider = new HoverProvider(
+      new DocumentManager(),
+      {
+        graphQL: async () => null,
+        filters: async () => [],
+        objects: async () => [],
+        liquidDrops: async () => [],
+        tags: async () => [
+          { name: 'if', description: 'if statement description' },
+          { name: 'echo', description: 'echo description' },
+        ],
+        systemTranslations: async () => ({}),
+      },
+      new TranslationProvider(new MockFileSystem({})),
+      async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    );
+  });
+
+  it('should return the hover description of the correct tag', async () => {
+    // cursor always points at character before █
+    await expect(provider).to.hover(`{%█ if cond %}{% endif %}`, expect.stringContaining('if'));
+    await expect(provider).to.hover(`{% i█f cond %}{% endif %}`, expect.stringContaining('if'));
+    await expect(provider).to.hover(`{% if█ cond %}{% endif %}`, expect.stringContaining('if'));
+    await expect(provider).to.hover(`{% if cond █%}{% endif %}`, expect.stringContaining('if'));
+    await expect(provider).to.hover(`{% if cond %}{% █ endif %}`, expect.stringContaining('if'));
+    await expect(provider).to.hover(`{% echo█ 'hi' %}`, expect.stringContaining('echo'));
+  });
+
+  it('should not return the tag hover description when hovering over anything else in the tag', async () => {
+    await expect(provider).to.not.hover(`{% if c█ond %}{% endif %}`, expect.stringContaining('if'));
+    await expect(provider).to.not.hover(
+      `{% if cond %} █ {%  endif %}`,
+      expect.stringContaining('if'),
+    );
+  });
+
+  it('should return nothing if there are no docs for that tag', async () => {
+    await expect(provider).to.hover(`{% unknown█ %}`, null);
+  });
+});

package/src/hover/providers/LiquidTagHoverProvider.ts

@@ -0,0 +1,33 @@
+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 LiquidTagHoverProvider implements BaseHoverProvider {
+  constructor(public themeDocset: ThemeDocset) {}
+
+  async hover(currentNode: LiquidHtmlNode): Promise<Hover | null> {
+    if (
+      currentNode.type !== NodeTypes.LiquidTag &&
+      currentNode.type !== NodeTypes.LiquidRawTag &&
+      currentNode.type !== NodeTypes.LiquidBranch
+    ) {
+      return null;
+    }
+
+    const name = currentNode.name;
+    const entries = await this.themeDocset.tags();
+    const entry = entries.find((entry) => entry.name === name);
+    if (!entry) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: render(entry, undefined, 'tag'),
+      },
+    };
+  }
+}

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

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { GetDocDefinitionForURI, DocDefinition } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+const uri = 'file:///snippets/product-card.liquid';
+
+describe('Module: RenderSnippetHoverProvider', async () => {
+  let provider: HoverProvider;
+  const mockSnippetDefinition: DocDefinition = {
+    uri,
+    liquidDoc: {
+      parameters: [
+        {
+          name: 'title',
+          description: 'The title of the product',
+          type: 'string',
+          required: true,
+          nodeType: 'param',
+        },
+      ],
+      description: {
+        content: 'This is a description',
+        nodeType: 'description',
+      },
+      examples: [
+        {
+          content: '{{ product }}',
+          nodeType: 'example',
+        },
+      ],
+    },
+  };
+
+  describe('hover', () => {
+    it('should return snippet definition with all parameters', async () => {
+      provider = createProvider(async () => mockSnippetDefinition);
+      // prettier-ignore
+      const expectedHoverContent = 
+`### product-card
+
+**Description:**
+
+
+This is a description
+
+**Parameters:**
+- \`title\`: string - The title of the product
+
+**Examples:**
+\`\`\`liquid
+{{ product }}
+\`\`\``;
+
+      await expect(provider).to.hover(`{% render 'product-car█d' %}`, expectedHoverContent);
+    });
+
+    it('should return nothing if not in render tag', async () => {
+      await expect(provider).to.hover(`{% assign asdf = 'snip█pet' %}`, null);
+      await expect(provider).to.hover(`{{ 'snip█pet' }}`, null);
+    });
+  });
+});
+
+const createProvider = (getSnippetDefinition: GetDocDefinitionForURI) => {
+  return new HoverProvider(
+    new DocumentManager(),
+    {
+      graphQL: async () => null,
+      filters: async () => [],
+      objects: async () => [],
+      liquidDrops: async () => [],
+      tags: async () => [],
+      systemTranslations: async () => ({}),
+    },
+    new TranslationProvider(new MockFileSystem({})),
+    async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    async () => ({}),
+    async () => [],
+    getSnippetDefinition,
+  );
+};

package/src/hover/providers/RenderPartialHoverProvider.ts

@@ -0,0 +1,38 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode, GetDocDefinitionForURI } from '@platformos/platformos-check-common';
+import { Hover, HoverParams } from 'vscode-languageserver';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+import { formatLiquidDocContentMarkdown } from '../../utils/liquidDoc';
+
+export class RenderPartialHoverProvider implements BaseHoverProvider {
+  constructor(private getDocDefinitionForURI: GetDocDefinitionForURI) {}
+
+  async hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null> {
+    const parentNode = ancestors.at(-1);
+    if (
+      currentNode.type !== NodeTypes.String ||
+      !parentNode ||
+      parentNode.type !== NodeTypes.RenderMarkup
+    ) {
+      return null;
+    }
+
+    const partialName = currentNode.value;
+    const docDefinition = await this.getDocDefinitionForURI(
+      params.textDocument.uri,
+      'app/views/partials',
+      partialName,
+    );
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: formatLiquidDocContentMarkdown(partialName, docDefinition),
+      },
+    };
+  }
+}

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

@@ -0,0 +1,70 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import { DocumentManager } from '../../documents';
+import { HoverProvider } from '../HoverProvider';
+import { MetafieldDefinitionMap } from '@platformos/platformos-check-common';
+import { GetDocDefinitionForURI, DocDefinition } from '@platformos/platformos-check-common';
+import { TranslationProvider } from '@platformos/platformos-common';
+import { MockFileSystem } from '@platformos/platformos-check-common/src/test';
+
+const uri = 'file:///snippets/product-card.liquid';
+
+describe('Module: RenderSnippetParameterHoverProvider', async () => {
+  let provider: HoverProvider;
+  let getSnippetDefinition: GetDocDefinitionForURI;
+  const mockSnippetDefinition: DocDefinition = {
+    uri,
+    liquidDoc: {
+      parameters: [
+        {
+          name: 'title',
+          description: 'The title of the product',
+          type: 'string',
+          required: true,
+          nodeType: 'param',
+        },
+      ],
+    },
+  };
+
+  describe('hover', () => {
+    beforeEach(() => {
+      provider = createProvider(async () => mockSnippetDefinition);
+    });
+
+    it('should return null if doc definition not found', async () => {
+      getSnippetDefinition = async () => undefined;
+      provider = createProvider(getSnippetDefinition);
+      await expect(provider).to.hover(`{% render 'product-card' tit█le: 'value' %}`, null);
+    });
+
+    it('should return null if parameter not found in doc definition', async () => {
+      await expect(provider).to.hover(`{% render 'product-card' unknown-para█m: 'value' %}`, null);
+    });
+
+    it('should return parameter info from doc definition', async () => {
+      await expect(provider).to.hover(
+        `{% render 'product-card' ti█tle: 'My Product' %}`,
+        '### `title`: string\n\nThe title of the product',
+      );
+    });
+  });
+});
+
+const createProvider = (getSnippetDefinition: GetDocDefinitionForURI) => {
+  return new HoverProvider(
+    new DocumentManager(),
+    {
+      graphQL: async () => null,
+      filters: async () => [],
+      objects: async () => [],
+      liquidDrops: async () => [],
+      tags: async () => [],
+      systemTranslations: async () => ({}),
+    },
+    new TranslationProvider(new MockFileSystem({})),
+    async (_rootUri: string) => ({} as MetafieldDefinitionMap),
+    async () => ({}),
+    async () => [],
+    getSnippetDefinition,
+  );
+};

package/src/hover/providers/RenderPartialParameterHoverProvider.ts

@@ -0,0 +1,47 @@
+import { NodeTypes } from '@platformos/liquid-html-parser';
+import { LiquidHtmlNode, GetDocDefinitionForURI } from '@platformos/platformos-check-common';
+import { Hover, HoverParams } from 'vscode-languageserver';
+import { BaseHoverProvider } from '../BaseHoverProvider';
+import { formatLiquidDocParameter } from '../../utils/liquidDoc';
+
+export class RenderPartialParameterHoverProvider implements BaseHoverProvider {
+  constructor(private getDocDefinitionForURI: GetDocDefinitionForURI) {}
+
+  async hover(
+    currentNode: LiquidHtmlNode,
+    ancestors: LiquidHtmlNode[],
+    params: HoverParams,
+  ): Promise<Hover | null> {
+    const parentNode = ancestors.at(-1);
+    if (
+      currentNode.type !== NodeTypes.NamedArgument ||
+      !parentNode ||
+      parentNode.type !== NodeTypes.RenderMarkup ||
+      parentNode.snippet.type !== NodeTypes.String
+    ) {
+      return null;
+    }
+
+    const docDefinition = await this.getDocDefinitionForURI(
+      params.textDocument.uri,
+      'app/views/partials',
+      parentNode.snippet.value,
+    );
+
+    const paramName = currentNode.name;
+    const hoveredParameter = docDefinition?.liquidDoc?.parameters?.find(
+      (parameter) => parameter.name === paramName,
+    );
+
+    if (!hoveredParameter) {
+      return null;
+    }
+
+    return {
+      contents: {
+        kind: 'markdown',
+        value: formatLiquidDocParameter(hoveredParameter, true),
+      },
+    };
+  }
+}