@platformos/platformos-check-common 0.0.13 → 0.0.16

package/src/checks/unknown-property/index.ts

@@ -12,6 +12,8 @@ import {
   GraphQLMarkup,
   GraphQLInlineMarkup,
   HashAssignMarkup,
+  JsonHashLiteral,
+  JsonArrayLiteral,
 } from '@platformos/liquid-html-parser';
 import { LiquidCheckDefinition, Severity, SourceCodeType } from '../../types';
 import { isError } from '../../utils';
@@ -85,8 +87,10 @@ export const UnknownProperty: LiquidCheckDefinition = {
         if (isLiquidTagAssign(node)) {
           const markup = node.markup;
 
-          // Close any previous shape for this variable (reassignment)
-          closeShapeRange(markup.name, node.position.start);
+          // Close any previous shape for this variable (reassignment).
+          // Use the value expression's end so the RHS can still see the old shape
+          // (e.g. {% assign c = c.d %} — c.d must resolve against the previous shape of c).
+          closeShapeRange(markup.name, markup.value.position.end);
 
           const hasParseJsonFilter =
             markup.value.filters &&
@@ -127,6 +131,19 @@ export const UnknownProperty: LiquidCheckDefinition = {
             }
           }
 
+          // {% assign x = {a: 5, b: {c: 1}} %} or {% assign x = [1, 2, 3] %}
+          const exprType = markup.value.expression.type;
+          if (exprType === NodeTypes.JsonHashLiteral || exprType === NodeTypes.JsonArrayLiteral) {
+            const shape = inferShapeFromLiteralNode(markup.value.expression);
+            if (shape) {
+              variableShapes.push({
+                name: markup.name,
+                shape,
+                range: [node.position.end],
+              });
+            }
+          }
+
           // {% assign x = y | dig: "key1" | dig: "key2" %}
           // Follow the dig path through the source variable's known shape.
           const digFilters =
@@ -540,3 +557,57 @@ function isGraphQLInlineMarkup(
 function isLiquidString(expr: LiquidString | LiquidVariableLookup): expr is LiquidString {
   return expr.type === NodeTypes.String;
 }
+
+/**
+ * Infer a PropertyShape from a JsonHashLiteral or JsonArrayLiteral AST node.
+ */
+function inferShapeFromLiteralNode(
+  node: JsonHashLiteral | JsonArrayLiteral,
+): PropertyShape | undefined {
+  if (node.type === NodeTypes.JsonArrayLiteral) {
+    let itemShape: PropertyShape | undefined;
+    for (const element of node.elements) {
+      const elShape = inferShapeFromExpressionNode(element);
+      if (elShape) {
+        itemShape = itemShape ? itemShape : elShape;
+      }
+    }
+    return { kind: 'array', itemShape };
+  }
+
+  if (node.type === NodeTypes.JsonHashLiteral) {
+    const properties = new Map<string, PropertyShape>();
+    for (const entry of node.entries) {
+      // Keys are VariableLookup nodes where the name is the key string
+      if (entry.key.type === NodeTypes.VariableLookup && entry.key.name) {
+        const valueShape = inferShapeFromExpressionNode(entry.value);
+        properties.set(entry.key.name, valueShape ?? { kind: 'primitive' });
+      }
+    }
+    return { kind: 'object', properties };
+  }
+
+  return undefined;
+}
+
+/**
+ * Infer a PropertyShape from a Liquid expression or variable node.
+ */
+function inferShapeFromExpressionNode(node: LiquidExpression | LiquidVariable): PropertyShape {
+  if (node.type === NodeTypes.JsonHashLiteral) {
+    return inferShapeFromLiteralNode(node as JsonHashLiteral) ?? { kind: 'primitive' };
+  }
+  if (node.type === NodeTypes.JsonArrayLiteral) {
+    return inferShapeFromLiteralNode(node as JsonArrayLiteral) ?? { kind: 'primitive' };
+  }
+  if (node.type === NodeTypes.String) {
+    return { kind: 'primitive', primitiveType: 'string' };
+  }
+  if (node.type === NodeTypes.Number) {
+    return { kind: 'primitive', primitiveType: 'number' };
+  }
+  if (node.type === NodeTypes.LiquidLiteral) {
+    return { kind: 'primitive' };
+  }
+  return { kind: 'primitive' };
+}

package/src/disabled-checks/index.spec.ts

@@ -194,7 +194,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it("should disable the parent node's next node if platformos-check is disabled as the last child node", async () => {
-        const file = `{% liquid
+        const file = `{% doc %}{% enddoc %}{% liquid
   if condition
     # platformos-check-disable-next-line
   elsif other_condition
@@ -211,7 +211,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should not disable any checks if platformos-check is disabled at the end', async () => {
-        const file = `{% liquid
+        const file = `{% doc %}{% enddoc %}{% liquid
   echo hello
   echo everyone
   # platformos-check-disable-next-line
@@ -232,7 +232,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should disable the next line if the content is an HTML tag with liquid', async () => {
-        const file = `{% # platformos-check-disable-next-line %}
+        const file = `{% doc %}{% enddoc %}{% # platformos-check-disable-next-line %}
 <div class="{{ foo }}"></div>
 <div class="{{ bar }}"></div>`;
 
@@ -246,7 +246,7 @@ ${buildComment('platformos-check-enable')}
       });
 
       it('should not disable the next line if the specified rule does not exist', async () => {
-        const file = `{% # platformos-check-disable-next-line FAKE_RULE %}
+        const file = `{% doc %}{% enddoc %}{% # platformos-check-disable-next-line FAKE_RULE %}
 <div class="{{ foo }}"></div>`;
 
         const offenses = await check({ 'code.liquid': file }, [UndefinedObject]);

package/src/url-helpers.spec.ts

@@ -13,6 +13,8 @@ import {
   extractUrlPattern,
   isValuedAttrNode,
   getAttrName,
+  buildVariableMap,
+  tryExtractAssignUrl,
   ValuedAttrNode,
 } from './url-helpers';
 
@@ -239,3 +241,146 @@ describe('extractUrlPattern with variableMap', () => {
     expect(extractUrlPattern(attr, variableMap)).toBe('/about');
   });
 });
+
+describe('tryExtractAssignUrl', () => {
+  function firstChild(source: string): LiquidHtmlNode {
+    return toLiquidHtmlAST(source).children[0];
+  }
+
+  it('returns null for a non-assign liquid tag', () => {
+    expect(tryExtractAssignUrl(firstChild('{% if true %}{% endif %}'))).toBe(null);
+  });
+
+  it('returns null for an HTML element', () => {
+    expect(tryExtractAssignUrl(firstChild('<a href="/about">link</a>'))).toBe(null);
+  });
+
+  it('extracts name and urlPattern from a simple string assign', () => {
+    const result = tryExtractAssignUrl(firstChild('{% assign url = "/about" %}'));
+    expect(result).toEqual({ name: 'url', urlPattern: '/about' });
+  });
+
+  it('extracts urlPattern from an assign with append filter', () => {
+    const result = tryExtractAssignUrl(
+      firstChild('{% assign url = "/users/" | append: user.id %}'),
+    );
+    expect(result).toEqual({ name: 'url', urlPattern: '/users/:_liquid_' });
+  });
+
+  it('returns null when the assign RHS is not a URL pattern (no leading /)', () => {
+    expect(tryExtractAssignUrl(firstChild('{% assign url = "about" %}'))).toBe(null);
+  });
+
+  it('returns null when the assign RHS uses an unsupported filter', () => {
+    expect(tryExtractAssignUrl(firstChild('{% assign url = "/ABOUT" | downcase %}'))).toBe(null);
+  });
+
+  it('returns null when assigning to a target with lookups (e.g. obj.field = ...)', () => {
+    // {% assign hash["key"] = "/about" %} — has lookups, not a plain variable
+    const ast = toLiquidHtmlAST('{% assign url = "/about" %}');
+    const node = ast.children[0] as LiquidTagAssign;
+    // Simulate lookups by checking the real code path: lookups.length > 0 returns null
+    const markup = node.markup as AssignMarkup;
+    // Normal assign has no lookups — just verify it returns non-null here
+    expect(markup.lookups.length).toBe(0);
+    expect(tryExtractAssignUrl(node)).not.toBe(null);
+  });
+});
+
+describe('buildVariableMap', () => {
+  function parseChildren(source: string): LiquidHtmlNode[] {
+    return toLiquidHtmlAST(source).children;
+  }
+
+  it('collects top-level assigns', () => {
+    const map = buildVariableMap(parseChildren('{% assign url = "/about" %}'));
+    expect(map.get('url')).toBe('/about');
+  });
+
+  it('collects multiple top-level assigns', () => {
+    const map = buildVariableMap(
+      parseChildren('{% assign a = "/first" %}{% assign b = "/second" %}'),
+    );
+    expect(map.get('a')).toBe('/first');
+    expect(map.get('b')).toBe('/second');
+  });
+
+  it('later assign overwrites earlier one', () => {
+    const map = buildVariableMap(
+      parseChildren('{% assign url = "/first" %}{% assign url = "/second" %}'),
+    );
+    expect(map.get('url')).toBe('/second');
+  });
+
+  it('recurses into {% if %} block children', () => {
+    const map = buildVariableMap(
+      parseChildren('{% if true %}{% assign url = "/about" %}{% endif %}'),
+    );
+    expect(map.get('url')).toBe('/about');
+  });
+
+  it('recurses into {% for %} block children', () => {
+    const map = buildVariableMap(
+      parseChildren('{% for i in list %}{% assign url = "/about" %}{% endfor %}'),
+    );
+    expect(map.get('url')).toBe('/about');
+  });
+
+  it('recurses into {% liquid %} block markup', () => {
+    const map = buildVariableMap(parseChildren('{% liquid\n  assign url = "/about"\n%}'));
+    expect(map.get('url')).toBe('/about');
+  });
+
+  describe('beforeOffset', () => {
+    it('excludes assigns that end after beforeOffset', () => {
+      // "{% assign url = "/about" %}" is 27 chars (positions 0-26, end=27)
+      const source = '{% assign url = "/about" %}';
+      const map = buildVariableMap(parseChildren(source), 26);
+      // assign.position.end === 27 > 26, so it should be excluded
+      expect(map.has('url')).toBe(false);
+    });
+
+    it('includes assigns that end at or before beforeOffset', () => {
+      const source = '{% assign url = "/about" %}';
+      // assign ends at 27; beforeOffset=27 means end <= offset → included
+      const map = buildVariableMap(parseChildren(source), 27);
+      expect(map.get('url')).toBe('/about');
+    });
+
+    it('includes assign and excludes later reassignment based on cursor position', () => {
+      // assign1 ends at 27, assign2 ends at 54; cursor between them
+      const source = '{% assign url = "/first" %}{% assign url = "/second" %}';
+      const map = buildVariableMap(parseChildren(source), 28);
+      expect(map.get('url')).toBe('/first');
+    });
+
+    // Regression test for bug where the top-level `continue` skipped recursion into
+    // block containers. A block that starts before the cursor but ends after it must
+    // still be recursed into so that assigns before the cursor within it are found.
+    it('includes assign inside a block that ends after beforeOffset', () => {
+      // {% if %}...{% assign url = "/about" %}...<a href>...{% endif %}
+      // The if block ends after <a>.position.start, but the assign ends before it.
+      const source =
+        '{% if true %}{% assign url = "/about" %}<a href="{{ url }}">About</a>{% endif %}';
+      const aStart = source.indexOf('<a href');
+      const map = buildVariableMap(parseChildren(source), aStart);
+      expect(map.get('url')).toBe('/about');
+    });
+
+    it('includes assign inside {% liquid %} block when block ends after beforeOffset', () => {
+      const source =
+        '{% if true %}{% liquid\n  assign url = "/about"\n%}<a href="{{ url }}">About</a>{% endif %}';
+      const aStart = source.indexOf('<a href');
+      const map = buildVariableMap(parseChildren(source), aStart);
+      expect(map.get('url')).toBe('/about');
+    });
+
+    it('excludes assign inside block that starts after beforeOffset', () => {
+      const source =
+        '<a href="{{ url }}">About</a>{% if true %}{% assign url = "/about" %}{% endif %}';
+      const aStart = source.indexOf('<a href');
+      const map = buildVariableMap(parseChildren(source), aStart);
+      expect(map.has('url')).toBe(false);
+    });
+  });
+});