@platformos/platformos-check-common 0.0.2

package/src/checks/liquid-html-syntax-error/checks/InvalidLoopArguments.ts

@@ -0,0 +1,116 @@
+import {
+  ForMarkup,
+  LiquidTag,
+  LiquidTagFor,
+  LiquidTagTablerow,
+  NodeTypes,
+} from '@platformos/liquid-html-parser';
+import { Problem, SourceCodeType, TagEntry } from '../../..';
+import {
+  doesFragmentContainUnsupportedParentheses,
+  getFragmentsInMarkup,
+  fragmentKeyValuePair,
+} from './utils';
+import { isLoopLiquidTag } from '../../utils';
+
+export function detectInvalidLoopArguments(
+  node: LiquidTag,
+  tags: TagEntry[] = [],
+): Problem<SourceCodeType.LiquidHtml> | undefined {
+  if (node.type === NodeTypes.LiquidTag && !isLoopLiquidTag(node)) {
+    return;
+  }
+
+  let markup: ForMarkup | string = (node as LiquidTagFor | LiquidTagTablerow).markup;
+
+  if (!markup) {
+    return;
+  }
+
+  if (typeof markup !== 'string') {
+    markup = markup.source.slice(markup.position.start, markup.position.end);
+  }
+
+  const fragments = getFragmentsInMarkup(markup);
+
+  // The first three fragments are: `<variable> in <array>`
+  // If they haven't started typing the tag, we don't want to report an error.
+  if (fragments.length <= 3) {
+    return;
+  }
+
+  const markupIndex = node.source.indexOf(markup, node.position.start);
+  let startIndex = markupIndex + fragments.at(3)!.index!;
+  let endIndex = markupIndex + fragments.at(-1)!.index! + fragments.at(-1)!.value.length;
+
+  const filteredFragments: string[] = [];
+
+  // Positional arguments are ignored if they come after invalid positional args or named args
+  let noMorePositionalArguments = false;
+  const invalidFragments: string[] = [];
+
+  for (let i = 3; i < fragments.length; i++) {
+    const fragment = fragments[i];
+
+    if (doesFragmentContainUnsupportedParentheses(fragment.value)) {
+      noMorePositionalArguments = true;
+      invalidFragments.push(fragment.value);
+      continue;
+    }
+
+    const keyValuePair = fragmentKeyValuePair(fragment.value);
+
+    // Named arg is found
+    if (keyValuePair) {
+      noMorePositionalArguments = true;
+
+      if (!isSupportedTagArgument(tags, node.name, keyValuePair.key, false)) {
+        invalidFragments.push(fragment.value);
+        continue;
+      }
+    }
+    // Unsupported positional arg is found
+    else if (
+      noMorePositionalArguments ||
+      !isSupportedTagArgument(tags, node.name, fragment.value, true)
+    ) {
+      noMorePositionalArguments = true;
+      invalidFragments.push(fragment.value);
+      continue;
+    }
+
+    filteredFragments.push(fragment.value);
+  }
+
+  if (invalidFragments.length === 0) {
+    return;
+  }
+
+  return {
+    message: `Arguments must be provided in the format \`${
+      node.name
+    } in <array> <positional arguments> <named arguments>\`. Invalid/Unknown arguments: ${invalidFragments.join(
+      ', ',
+    )}`,
+    startIndex,
+    endIndex,
+    fix: (corrector) => {
+      corrector.replace(startIndex, endIndex, filteredFragments.join(' '));
+    },
+  };
+}
+
+function isSupportedTagArgument(
+  tags: TagEntry[],
+  tagName: string,
+  key: string,
+  positional: boolean,
+) {
+  return (
+    tags
+      .find((tag) => tag.name === tagName)
+      ?.parameters?.some(
+        (parameter) => parameter.name === key && parameter.positional === positional,
+      ) || false
+  );
+}

package/src/checks/liquid-html-syntax-error/checks/InvalidLoopRange.spec.ts

@@ -0,0 +1,84 @@
+import { expect, describe, it, vi, beforeEach } from 'vitest';
+import { applyFix, runLiquidCheck } from '../../../test';
+import { LiquidHTMLSyntaxError } from '../index';
+import { INVALID_LOOP_RANGE_MESSAGE } from './InvalidLoopRange';
+
+describe('detectInvalidLoopRange', async () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should not report when range is valid', async () => {
+    const testCases = [
+      `{% for i in (1..10) %}{% endfor %}`,
+      `{% tablerow x in (a..b) %}{% endtablerow %}`,
+    ];
+
+    for (const sourceCode of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should report when there is an extra `.` character in range', async () => {
+    const testCases = [
+      [`{% for i in (1...10) %}{% endfor %}`, '{% for i in (1..10) %}{% endfor %}'],
+      [
+        `{% tablerow x in (a...b) %}{% endtablerow %}`,
+        '{% tablerow x in (a..b) %}{% endtablerow %}',
+      ],
+      [
+        `{% tablerow x in (a .. b) %}{% endtablerow %}`,
+        '{% tablerow x in (a..b) %}{% endtablerow %}',
+      ],
+      [
+        `{% tablerow x in ( a..b ) %}{% endtablerow %}`,
+        '{% tablerow x in (a..b) %}{% endtablerow %}',
+      ],
+    ];
+
+    for (const [sourceCode, expected] of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal(INVALID_LOOP_RANGE_MESSAGE);
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+
+  it('should report when the range contains a real number', async () => {
+    const sourceCode = `{% for i in (-2.9..2.9) %}{% endfor %}`;
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(INVALID_LOOP_RANGE_MESSAGE);
+
+    const fixed = applyFix(sourceCode, offenses[0]);
+    expect(fixed).to.equal(`{% for i in (-2..2) %}{% endfor %}`);
+  });
+
+  it('should report when the range contains a nested variable', async () => {
+    const sourceCode = `{% for i in (some.var..some.other.var) %}{% endfor %}`;
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should report when there are multiple instances of the error', async () => {
+    const sourceCode = `{% for i in (1...10) %}{% endfor %} {% tablerow x in (a...b) %}{% endtablerow %}`;
+
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+    expect(offenses).to.have.length(2);
+    expect(offenses[0].message).to.equal(INVALID_LOOP_RANGE_MESSAGE);
+    expect(offenses[1].message).to.equal(INVALID_LOOP_RANGE_MESSAGE);
+
+    const fixed = applyFix(sourceCode, offenses[0]);
+    expect(fixed).to.equal(
+      `{% for i in (1..10) %}{% endfor %} {% tablerow x in (a...b) %}{% endtablerow %}`,
+    );
+
+    const fixed2 = applyFix(sourceCode, offenses[1]);
+    expect(fixed2).to.equal(
+      `{% for i in (1...10) %}{% endfor %} {% tablerow x in (a..b) %}{% endtablerow %}`,
+    );
+  });
+});

package/src/checks/liquid-html-syntax-error/checks/InvalidLoopRange.ts

@@ -0,0 +1,79 @@
+import {
+  LiquidTag,
+  LiquidTagFor,
+  LiquidTagTablerow,
+  NodeTypes,
+} from '@platformos/liquid-html-parser';
+import { Problem, SourceCodeType } from '../../..';
+import { getRangeMatch } from './utils';
+import { isLoopLiquidTag } from '../../utils';
+
+export const INVALID_LOOP_RANGE_MESSAGE =
+  'Ranges must be in the format `(<start>..<end>)`. The start and end of the range must be whole numbers or variables.';
+
+export function detectInvalidLoopRange(
+  node: LiquidTag,
+): Problem<SourceCodeType.LiquidHtml> | undefined {
+  if (node.type === NodeTypes.LiquidTag && !isLoopLiquidTag(node)) {
+    return;
+  }
+
+  const markup = (node as LiquidTagFor | LiquidTagTablerow).markup;
+
+  if (!markup) {
+    return;
+  }
+
+  if (typeof markup === 'string') {
+    return validateMarkup(node, markup);
+  }
+
+  if (markup.collection.type === NodeTypes.Range) {
+    return validateMarkup(
+      node,
+      node.source.slice(markup.collection.position.start, markup.collection.position.end),
+    );
+  }
+}
+
+function validateMarkup(
+  node: LiquidTag,
+  markup: string,
+): Problem<SourceCodeType.LiquidHtml> | undefined {
+  const match = getRangeMatch(markup);
+  if (!match || match.index === undefined) {
+    return;
+  }
+
+  const [fullMatch, start, , end] = match;
+
+  let startCleaned = start;
+  let endCleaned = end;
+
+  if (!isNaN(Number(start)) && Number(start) % 1 !== 0) {
+    startCleaned = `${Math.trunc(Number(start))}`;
+  }
+  if (!isNaN(Number(end)) && Number(end) % 1 !== 0) {
+    endCleaned = `${Math.trunc(Number(end))}`;
+  }
+
+  const expectedRangeMarkup = `(${startCleaned}..${endCleaned})`;
+
+  if (markup.slice(match.index, match.index + fullMatch.length) === expectedRangeMarkup) {
+    return;
+  }
+
+  const markupIndex = node.source.indexOf(markup, node.position.start);
+
+  const startIndex = markupIndex + match.index;
+  const endIndex = startIndex + fullMatch.length;
+
+  return {
+    message: INVALID_LOOP_RANGE_MESSAGE,
+    startIndex,
+    endIndex,
+    fix: (corrector) => {
+      corrector.replace(startIndex, endIndex, expectedRangeMarkup);
+    },
+  };
+}

package/src/checks/liquid-html-syntax-error/checks/InvalidPipeSyntax.spec.ts

@@ -0,0 +1,184 @@
+import { describe, it, expect } from 'vitest';
+import { runLiquidCheck, applyFix } from '../../../test';
+import { LiquidHTMLSyntaxError } from '../index';
+
+describe('Module: InvalidPipeSyntax', () => {
+  describe('Double pipe patterns', () => {
+    it('should detect and fix double pipes in variable output', async () => {
+      const sourceCode = `{{ 'hello' | upcase | | downcase }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain('Remove extra `|` character(s)');
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{{ 'hello' | upcase | downcase }}`);
+    });
+
+    it('should detect and fix double pipes with extra whitespace', async () => {
+      const sourceCode = `{{ 'hello' | upcase |   | downcase }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain('Remove extra `|` character(s)');
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{{ 'hello' | upcase | downcase }}`);
+    });
+
+    it('should detect and fix double pipes in assign tag', async () => {
+      const sourceCode = `{% assign result = 'hello' | upcase | | downcase %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain('Remove extra `|` character(s)');
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{% assign result = 'hello' | upcase | downcase %}`);
+    });
+
+    it('should detect and fix double pipes in echo tag', async () => {
+      const sourceCode = `{% echo 'hello' | upcase | | downcase %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain('Remove extra `|` character(s)');
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{% echo 'hello' | upcase | downcase %}`);
+    });
+
+    it('should handle multiple double pipes in one expression', async () => {
+      const sourceCode = `{{ 'hello' | upcase | | downcase | | reverse }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(2);
+
+      expect(offenses[0].message).toContain('Remove extra `|` character(s)');
+      expect(offenses[1].message).toContain('Remove extra `|` character(s)');
+
+      expect(offenses[0].fix).toBeDefined();
+      expect(offenses[1].fix).toBeDefined();
+    });
+  });
+
+  describe('Trailing pipe patterns', () => {
+    it('should detect and fix trailing pipe in variable output', async () => {
+      const sourceCode = `{{ 'hello' | upcase | }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain('Remove the trailing `|` character');
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{{ 'hello' | upcase }}`);
+    });
+
+    it('should detect and fix trailing pipe in assign tag', async () => {
+      const sourceCode = `{% assign result = 'hello' | upcase | %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain('Remove the trailing `|` character');
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{% assign result = 'hello' | upcase %}`);
+    });
+
+    it('should detect and fix trailing pipe in echo tag', async () => {
+      const sourceCode = `{% echo 'hello' | upcase | %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(1);
+      expect(offenses[0].message).toContain('Remove the trailing `|` character');
+      expect(offenses[0].fix).toBeDefined();
+
+      const fixedCode = applyFix(sourceCode, offenses[0]);
+      expect(fixedCode).toBe(`{% echo 'hello' | upcase %}`);
+    });
+
+    it('should detect and fix multiple trailing pipes', async () => {
+      const sourceCode = `{{ 'hello' | upcase | | }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(2); // Double pipe AND trailing pipe
+      expect(offenses[0].message).toContain('Remove extra `|` character(s)');
+      expect(offenses[1].message).toContain('Remove the trailing `|` character');
+      expect(offenses[0].fix).toBeDefined();
+      expect(offenses[1].fix).toBeDefined();
+    });
+  });
+
+  describe('Complex pipe scenarios', () => {
+    it('should handle mixed valid and invalid pipes', async () => {
+      const sourceCode = `{{ 'hello' | upcase | | downcase | reverse | }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(2);
+
+      // First should be double pipe
+      expect(offenses[0].message).toContain('Remove extra `|` character(s)');
+      // Second should be trailing pipe
+      expect(offenses[1].message).toContain('Remove the trailing `|` character');
+    });
+
+    it('should not interfere with valid filter parameter syntax', async () => {
+      const sourceCode = `{{ 'hello' | append: 'world' | upcase }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should handle liquid tag with mixed pipe issues', async () => {
+      const sourceCode = `{% liquid
+        assign foo = 'test' | upcase | | downcase |
+        echo bar | reverse
+      %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(2);
+      expect(offenses[0].message).toContain('Remove extra `|` character(s)');
+      expect(offenses[1].message).toContain('Remove the trailing `|` character');
+    });
+  });
+
+  describe('Valid syntax should not be flagged', () => {
+    it('should not report on valid filter chains', async () => {
+      const sourceCode = `{{ 'hello' | upcase | append: 'world' | downcase }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report on simple filters', async () => {
+      const sourceCode = `{{ 'hello' | upcase }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report on filters with arguments', async () => {
+      const sourceCode = `{{ product.title | append: ' - ' | append: shop.name }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report on valid assign with filters', async () => {
+      const sourceCode = `{% assign title = product.title | upcase | truncate: 50 %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report on valid echo with filters', async () => {
+      const sourceCode = `{% echo product.title | upcase | truncate: 50 %}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+  });
+
+  describe('Edge cases', () => {
+    it('should handle pipes in string literals correctly', async () => {
+      const sourceCode = `{{ 'hello | world' | upcase }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+
+    it('should not report on conditional expressions with pipes', async () => {
+      const sourceCode = `{{ product.title | default: 'No title' }}`;
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).toHaveLength(0);
+    });
+  });
+});

package/src/checks/liquid-html-syntax-error/checks/InvalidPipeSyntax.ts

@@ -0,0 +1,91 @@
+import {
+  LiquidVariableOutput,
+  LiquidTag,
+  NodeTypes,
+  NamedTags,
+} from '@platformos/liquid-html-parser';
+import { Problem, SourceCodeType } from '../../..';
+import { INVALID_SYNTAX_MESSAGE } from './utils';
+
+export async function detectInvalidPipeSyntax(
+  node: LiquidVariableOutput | LiquidTag,
+): Promise<Problem<SourceCodeType.LiquidHtml>[]> {
+  if (node.type === NodeTypes.LiquidVariableOutput) {
+    if (typeof node.markup !== 'string') {
+      return [];
+    }
+    return detectPipeSyntaxInMarkup(node, node.markup);
+  }
+
+  if (node.type === NodeTypes.LiquidTag) {
+    if (node.name === NamedTags.echo && typeof node.markup !== 'string') {
+      return [];
+    }
+    if (node.name === NamedTags.assign && typeof node.markup !== 'string') {
+      return [];
+    }
+    if (
+      typeof node.markup === 'string' &&
+      (node.name === NamedTags.echo || node.name === NamedTags.assign)
+    ) {
+      return detectPipeSyntaxInMarkup(node, node.markup);
+    }
+  }
+
+  return [];
+}
+
+async function detectPipeSyntaxInMarkup(
+  node: LiquidVariableOutput | LiquidTag,
+  markup: string,
+): Promise<Problem<SourceCodeType.LiquidHtml>[]> {
+  const problems: Problem<SourceCodeType.LiquidHtml>[] = [];
+  const trimmedMarkup = markup.trim();
+
+  // Check for multiple consecutive pipes
+  const extraPipesPattern = /(\|\s*){2,}/g;
+  const extraPipesMatches = Array.from(trimmedMarkup.matchAll(extraPipesPattern));
+
+  for (const match of extraPipesMatches) {
+    const markupStartInSource = node.source.indexOf(markup, node.position.start);
+    if (markupStartInSource === -1) {
+      continue;
+    }
+    const problemStartInSource = markupStartInSource + match.index!;
+    const problemEndInSource = problemStartInSource + match[0].length;
+
+    problems.push({
+      message: `${INVALID_SYNTAX_MESSAGE}. Remove extra \`|\` character(s).`,
+      startIndex: problemStartInSource,
+      endIndex: problemEndInSource,
+      fix: (corrector) => {
+        corrector.replace(problemStartInSource, problemEndInSource, '| ');
+      },
+    });
+  }
+
+  // Check for trailing pipes
+  const trailingPipePattern = /\s*\|\s*$/;
+  const trailingPipeMatch = trimmedMarkup.match(trailingPipePattern);
+
+  if (trailingPipeMatch) {
+    const markupStartInSource = node.source.indexOf(markup, node.position.start);
+    if (markupStartInSource === -1) {
+      return problems;
+    }
+    const trailingPipeStartInMarkup = trailingPipeMatch.index!;
+    const problemStartInSource = markupStartInSource + trailingPipeStartInMarkup;
+    const problemEndInSource = problemStartInSource + trailingPipeMatch[0].length;
+
+    problems.push({
+      message: `${INVALID_SYNTAX_MESSAGE}. Remove the trailing \`|\` character.`,
+      startIndex: problemStartInSource,
+      endIndex: problemEndInSource,
+      fix: (corrector) => {
+        corrector.replace(problemStartInSource, problemEndInSource, '');
+      },
+    });
+  }
+
+  return problems;
+}

package/src/checks/liquid-html-syntax-error/checks/MultipleAssignValues.spec.ts

@@ -0,0 +1,82 @@
+import { expect, describe, it, vi, beforeEach } from 'vitest';
+import { applyFix, runLiquidCheck } from '../../../test';
+import { LiquidHTMLSyntaxError } from '../index';
+
+describe('detectMultipleAssignValues', async () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should not report when there are no trailing values', async () => {
+    const testCases = [`{% assign foo = '123' %}`, `{% assign foo = '123' | upcase %}`];
+
+    for (const sourceCode of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should report when there are multiple values (no filters)', async () => {
+    const testCases = [
+      [`{% assign foo = '123' 555 text %}`, "{% assign foo = '123' %}"],
+      [`{% assign foo = "123" 555 text %}`, '{% assign foo = "123" %}'],
+      [`{% assign foo = 123 555 text %}`, '{% assign foo = 123 %}'],
+      [`{% assign foo = true 555 text %}`, '{% assign foo = true %}'],
+    ];
+
+    for (const [sourceCode, expected] of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Syntax is not supported');
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+
+  it('should not report when there are no filters provided', async () => {
+    const sourceCode = `{% assign foo = '123' %}`;
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+    expect(offenses).to.have.length(0);
+  });
+
+  it('should report when there are multiple instances of the error', async () => {
+    const sourceCode = `{% assign foo = blank %} {% assign foo = '123' 555 text %} {% assign foo = '123' 555 text %}`;
+
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+    expect(offenses).to.have.length(2);
+    expect(offenses[0].message).to.equal('Syntax is not supported');
+    expect(offenses[1].message).to.equal('Syntax is not supported');
+
+    const fixed = applyFix(sourceCode, offenses[0]);
+    expect(fixed).to.equal(
+      `{% assign foo = blank %} {% assign foo = '123' %} {% assign foo = '123' 555 text %}`,
+    );
+
+    const fixed2 = applyFix(sourceCode, offenses[1]);
+    expect(fixed2).to.equal(
+      `{% assign foo = blank %} {% assign foo = '123' 555 text %} {% assign foo = '123' %}`,
+    );
+  });
+
+  it('should report when there are multiple values (with filters)', async () => {
+    const testCases = [
+      [`{% assign foo = '123' 555 text | upcase %}`, "{% assign foo = '123' | upcase %}"],
+      [`{% assign foo = "123" 555 text | upcase %}`, '{% assign foo = "123" | upcase %}'],
+      [`{% assign foo = 123 555 text | default: 0 %}`, '{% assign foo = 123 | default: 0 %}'],
+      [
+        `{% assign foo = true 555 text | fake-filter: 'yes' %}`,
+        "{% assign foo = true | fake-filter: 'yes' %}",
+      ],
+    ];
+
+    for (const [sourceCode, expected] of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.equal('Syntax is not supported');
+
+      const fixed = applyFix(sourceCode, offenses[0]);
+      expect(fixed).to.equal(expected);
+    }
+  });
+});