@platformos/platformos-check-common 0.0.2

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

@@ -0,0 +1,385 @@
+import { expect, describe, it } from 'vitest';
+import { runLiquidCheck, applyFix } from '../../../test';
+import { LiquidHTMLSyntaxError } from '..';
+
+describe('Module: InvalidConditionalBooleanExpression', () => {
+  it('should not report an offense for valid boolean expressions', async () => {
+    const testCases = [
+      '{% if 1 > 2 %}hello{% endif %}',
+      '{% if variable == 5 %}hello{% endif %}',
+      "{% if 'abc' contains 'a' %}hello{% endif %}",
+      "{% if product.title != '' %}hello{% endif %}",
+      '{% if 1 and 2 %}hello{% endif %}',
+      '{% if true or false %}hello{% endif %}',
+      '{% if 10 > 5 and user.active %}hello{% endif %}',
+      '{% if price >= 100 or discount %}hello{% endif %}',
+      "{% if user.name contains 'admin' or user.role == 'owner' %}hello{% endif %}",
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report an offense for valid single values', async () => {
+    const testCases = [
+      '{% if variable %}hello{% endif %}',
+      '{% if user.active %}hello{% endif %}',
+      '{% if true %}hello{% endif %}',
+      '{% if false %}hello{% endif %}',
+      '{% if 1 %}hello{% endif %}',
+      '{% if 0 %}hello{% endif %}',
+      "{% if 'string' %}hello{% endif %}",
+      '{% if contains %}hello{% endif %}',
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should report an offense when parser stops at numbers', async () => {
+    const source = '{% if 7 1 > 100 %}hello{% endif %}';
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, source);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      "Syntax is not supported: Expression stops at truthy value '7', and will ignore: '1 > 100'",
+    );
+
+    const fixed = applyFix(source, offenses[0]);
+    expect(fixed).to.equal('{% if 7 %}hello{% endif %}');
+  });
+
+  it('should report an offense when parser stops at strings', async () => {
+    const source = "{% if 'hello' 1 > 100 %}world{% endif %}";
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, source);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      "Syntax is not supported: Expression stops at truthy value ''hello'', and will ignore: '1 > 100'",
+    );
+
+    const fixed = applyFix(source, offenses[0]);
+    expect(fixed).to.equal("{% if 'hello' %}world{% endif %}");
+  });
+
+  it('should report an offense when parser stops at liquid literals', async () => {
+    const testCases = [
+      { source: '{% if true 1 > 0 %}hello{% endif %}', value: 'true' },
+      { source: '{% if false 1 > 0 %}hello{% endif %}', value: 'false' },
+      { source: '{% if nil 6 > 5 %}hello{% endif %}', value: 'nil' },
+      { source: '{% if empty 123 456 %}hello{% endif %}', value: 'empty' },
+      { source: '{% if blank 789 %}hello{% endif %}', value: 'blank' },
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase.source);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.contain(
+        `Expression stops at truthy value '${testCase.value}'`,
+      );
+
+      const fixed = applyFix(testCase.source, offenses[0]);
+      expect(fixed).to.equal(`{% if ${testCase.value} %}hello{% endif %}`);
+    }
+  });
+
+  it('should report offenses in different liquid tag types', async () => {
+    const testCases = [
+      '{% if 7 1 > 100 %}hello{% endif %}',
+      "{% unless 'test' 42 > 0 %}hello{% endunless %}",
+      '{% if false %}no{% elsif 7 1 > 100 %}hello{% endif %}',
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.contain('Expression stops at truthy value');
+    }
+  });
+
+  it('should report an offense for malformed expression starting with invalid token', async () => {
+    const source = '{% if > 2 %}hello{% endif %}';
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, source);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      "Syntax is not supported: Conditional cannot start with '>'. Use a variable or value instead",
+    );
+
+    const fixed = applyFix(source, offenses[0]);
+    expect(fixed).to.equal('{% if false %}hello{% endif %}');
+  });
+
+  it('should report an offense for bare operators with no operands', async () => {
+    const testCases = [
+      { source: '{% if > %}hello{% endif %}', token: '>' },
+      { source: '{% if == %}hello{% endif %}', token: '==' },
+      { source: '{% if < %}hello{% endif %}', token: '<' },
+      { source: '{% if != %}hello{% endif %}', token: '!=' },
+      { source: '{% if >= %}hello{% endif %}', token: '>=' },
+      { source: '{% if <= %}hello{% endif %}', token: '<=' },
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase.source);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.contain(`Conditional cannot start with '${testCase.token}'`);
+
+      const fixed = applyFix(testCase.source, offenses[0]);
+      expect(fixed).to.equal('{% if false %}hello{% endif %}');
+    }
+  });
+
+  it('should report an offense for other invalid starting characters', async () => {
+    const testCases = [
+      { source: '{% if @ %}hello{% endif %}', token: '@' },
+      { source: '{% if # %}hello{% endif %}', token: '#' },
+      { source: '{% if $ %}hello{% endif %}', token: '$' },
+      { source: '{% if & %}hello{% endif %}', token: '&' },
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase.source);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.contain(`Conditional cannot start with '${testCase.token}'`);
+
+      const fixed = applyFix(testCase.source, offenses[0]);
+      expect(fixed).to.equal('{% if false %}hello{% endif %}');
+    }
+  });
+
+  it('should report an offense for malformed expressions in complex expressions', async () => {
+    const testCases = [
+      '{% if > 5 and true %}hello{% endif %}',
+      '{% if == 2 or false %}hello{% endif %}',
+      '{% if < 10 and variable %}hello{% endif %}',
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.contain('Conditional cannot start with');
+
+      const fixed = applyFix(testCase, offenses[0]);
+      expect(fixed).to.equal('{% if false %}hello{% endif %}');
+    }
+  });
+
+  it('should report an offense for trailing tokens after comparison', async () => {
+    const source = '{% if 1 == 2 foobar %}hello{% endif %}';
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, source);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.equal(
+      "Syntax is not supported: Conditional is invalid. Anything after '1 == 2' will be ignored",
+    );
+
+    const fixed = applyFix(source, offenses[0]);
+    expect(fixed).to.equal('{% if 1 == 2 %}hello{% endif %}');
+  });
+
+  it('should report an offense for malformed comparisons like missing quotes', async () => {
+    const testCases = [
+      {
+        source: "{% if 'wat' == 'squat > 2 %}hello{% endif %}",
+        description: 'missing closing quote creates trailing comparison',
+      },
+      {
+        source: "{% if 'wat' == 'squat' > 2 %}hello{% endif %}",
+        description: 'extra comparison after valid comparison',
+      },
+      {
+        source: "{% if price == 'test' != 5 %}hello{% endif %}",
+        description: 'chained comparisons without logical operators',
+      },
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase.source);
+      expect(offenses, `Failed for: ${testCase.description}`).to.have.length(1);
+      expect(offenses[0].message).to.contain('Anything after');
+    }
+  });
+
+  it('should report an offense for multiple trailing tokens', async () => {
+    const source = '{% if 10 > 4 baz qux %}hello{% endif %}';
+    const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, source);
+
+    expect(offenses).to.have.length(1);
+    expect(offenses[0].message).to.contain('Anything after');
+
+    const fixed = applyFix(source, offenses[0]);
+    expect(fixed).to.equal('{% if 10 > 4 %}hello{% endif %}');
+  });
+
+  it('should report an offense for trailing junk with different operators', async () => {
+    const testCases = [
+      "{% if 'abc' contains 'a' noise %}hello{% endif %}",
+      '{% if price <= 50 extra %}hello{% endif %}',
+      '{% if count != 0 junk %}hello{% endif %}',
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.contain('Anything after');
+    }
+  });
+
+  it('should not report an offense for valid logical continuations', async () => {
+    const testCases = [
+      '{% if 1 > 0 and 2 < 3 %}hello{% endif %}',
+      '{% if x == 5 or y != 10 %}hello{% endif %}',
+      '{% if price >= 100 and discount %}hello{% endif %}',
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report an offense for truthy values followed by logical operators', async () => {
+    const testCases = [
+      '{% if true and variable %}hello{% endif %}',
+      '{% if false or variable %}hello{% endif %}',
+      '{% if 1 and user.active %}hello{% endif %}',
+      '{% if 0 or fallback %}hello{% endif %}',
+      "{% if 'string' and condition %}hello{% endif %}",
+      "{% if 'value' or default %}hello{% endif %}",
+      '{% if 42 and check %}hello{% endif %}',
+      '{% if 3.14 or backup %}hello{% endif %}',
+      '{% if nil and something %}hello{% endif %}',
+      '{% if empty or alternative %}hello{% endif %}',
+      '{% if blank and other %}hello{% endif %}',
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report an offense for complex expressions with truthy values and logical operators', async () => {
+    const testCases = [
+      '{% if true and variable > 5 %}hello{% endif %}',
+      "{% if 'test' or user.name == 'admin' %}hello{% endif %}",
+      '{% if 42 and price <= 100 %}hello{% endif %}',
+      '{% if false or count != 0 %}hello{% endif %}',
+      "{% if empty and product.title contains 'sale' %}hello{% endif %}",
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report an offense for unknown operators errors after values (Liquid catches these)', async () => {
+    const testCases = [
+      '{% if my_var word > 5 %}hello{% endif %}',
+      '{% if jake johnson > 5 %}hello{% endif %}',
+      "{% if 'test' invalid > thing %}hello{% endif %}",
+      "{% if user.name custom 'admin' %}hello{% endif %}",
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report an offense for unknown operators after variables', async () => {
+    const testCases = [
+      '{% if variable unknown > 5 %}hello{% endif %}',
+      "{% if user.role badop 'admin' %}hello{% endif %}",
+      '{% if price fake 100 %}hello{% endif %}',
+      '{% if "str" blue == something %}hello{% endif %}',
+      '{% if red blue > something %}hello{% endif %}',
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report an offense for unknown operators in complex expressions', async () => {
+    const testCases = [
+      "{% if user.active and name fake 'test' %}hello{% endif %}",
+      "{% unless 'test' some > thing %}hello{% endunless %}",
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should not report an offense for pipe filter expressions', async () => {
+    const testCases = ['{% if wat | something == something %}hello{% endif %}'];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should report an offense for misspelled logical operators', async () => {
+    const testCases = [
+      {
+        source: '{% if "wat" == "squat" adn "wat" == "squat" %}hello{% endif %}',
+        misspelled: 'adn',
+        expectedFix: '"wat" == "squat"',
+      },
+      {
+        source: '{% if variable > 5 andd other < 10 %}hello{% endif %}',
+        misspelled: 'andd',
+        expectedFix: 'variable > 5',
+      },
+    ];
+
+    for (const testCase of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase.source);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.contain('Anything after');
+
+      const fixed = applyFix(testCase.source, offenses[0]);
+      expect(fixed).to.contain(testCase.expectedFix);
+    }
+  });
+
+  it('should report special message for JavaScript-style operators after literal values', async () => {
+    const testCases = [
+      '{% if true && false %}hello{% endif %}',
+      '{% if false || true %}hello{% endif %}',
+      '{% if "hello" && world %}hello{% endif %}',
+      '{% if 42 || something %}hello{% endif %}',
+    ];
+
+    for (const source of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, source);
+      expect(offenses).to.have.length(1);
+      expect(offenses[0].message).to.contain(
+        "Use 'and'/'or' instead of '&&'/'||' for multiple conditions",
+      );
+    }
+  });
+
+  it('should NOT report an offense for valid logical operators', async () => {
+    const validCases = [
+      '{% if price > 100 and discount < 50 %}hello{% endif %}',
+      '{% if user.active or user.premium %}hello{% endif %}',
+      '{% if x == 1 and y == 2 or z == 3 %}hello{% endif %}',
+    ];
+
+    for (const testCase of validCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, testCase);
+      expect(offenses).to.have.length(0);
+    }
+  });
+});

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

@@ -0,0 +1,165 @@
+import { LiquidBranch, LiquidTag } from '@platformos/liquid-html-parser';
+import { SourceCodeType, Problem } from '../../..';
+import { getValuesInMarkup, INVALID_SYNTAX_MESSAGE } from './utils';
+
+type TokenType = 'variable' | keyof typeof TOKEN_PATTERNS;
+
+interface Token {
+  value: string;
+  type: TokenType;
+}
+
+interface ExpressionIssue {
+  message: string;
+  fix: string;
+}
+
+const TOKEN_PATTERNS = {
+  logical: /^(and|or)$/,
+  comparison: /^(==|!=|>=|<=|>|<|contains)$/,
+  invalid: /^[@#$&]$/,
+  literal: /^(['"][^'"]*['"]|\d+(?:\.\d+)?|true|false|nil|empty|blank)$/,
+} as const;
+
+function classifyToken(value: string): TokenType {
+  for (const [type, pattern] of Object.entries(TOKEN_PATTERNS)) {
+    if (pattern.test(value)) {
+      return type as TokenType;
+    }
+  }
+  return 'variable';
+}
+
+export function detectInvalidConditionalNode(
+  node: LiquidBranch | LiquidTag,
+): Problem<SourceCodeType.LiquidHtml> | undefined {
+  if (!('name' in node) || !node.name) return;
+  if (!['if', 'elsif', 'unless'].includes(String(node.name))) return;
+
+  const markup = node.markup;
+  if (typeof markup !== 'string' || !markup.trim()) return;
+
+  const issue = analyzeConditionalExpression(markup);
+  if (!issue) return;
+
+  const openingTagRange = node.blockStartPosition || node.position;
+  const openingTag = node.source.slice(openingTagRange.start, openingTagRange.end);
+  const markupOffsetInOpening = openingTag.indexOf(markup);
+  if (markupOffsetInOpening < 0) return;
+
+  const startIndex = openingTagRange.start + markupOffsetInOpening;
+  const endIndex = startIndex + markup.length;
+
+  return {
+    message: `${INVALID_SYNTAX_MESSAGE}: ${issue.message}`,
+    startIndex,
+    endIndex,
+    fix: (corrector) => {
+      corrector.replace(startIndex, endIndex, issue.fix);
+    },
+  };
+}
+
+function isValueToken(token: Token): boolean {
+  return token.type === 'literal' || token.type === 'variable';
+}
+
+function isOperatorToken(token: Token): boolean {
+  return token.type === 'logical' || token.type === 'comparison';
+}
+
+function checkInvalidStartingToken(tokens: Token[]): ExpressionIssue | null {
+  const firstToken = tokens[0];
+  if (firstToken.type === 'invalid' || firstToken.type === 'comparison') {
+    return {
+      message: `Conditional cannot start with '${firstToken.value}'. Use a variable or value instead`,
+      fix: 'false',
+    };
+  }
+  return null;
+}
+
+function checkTrailingTokensAfterComparison(tokens: Token[]): ExpressionIssue | null {
+  const COMPARISON_LENGTH = 3;
+  const minTokensForTrailing = COMPARISON_LENGTH + 1;
+
+  for (let i = 0; i <= tokens.length - minTokensForTrailing; i++) {
+    const [v1, op, v2] = tokens.slice(i, i + 3);
+    const remaining = tokens.slice(i + 3);
+
+    if (isValueToken(v1) && op.type === 'comparison' && isValueToken(v2)) {
+      if (remaining.length > 0) {
+        if (remaining[0].type !== 'logical') {
+          const validExpr = tokens
+            .slice(0, i + 3)
+            .map((t) => t.value)
+            .join(' ');
+          const junk = remaining.map((t) => t.value).join(' ');
+          const containsLogicalOperators = /&&|\|\|/.test(junk);
+
+          if (containsLogicalOperators) {
+            return {
+              message: `Conditional is invalid. Anything after '${validExpr}' will be ignored. Use 'and'/'or' instead of '&&'/'||' for multiple conditions`,
+              fix: validExpr,
+            };
+          } else {
+            return {
+              message: `Conditional is invalid. Anything after '${validExpr}' will be ignored`,
+              fix: validExpr,
+            };
+          }
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function checkLaxParsingIssues(tokens: Token[]): ExpressionIssue | null {
+  for (let i = 0; i < tokens.length - 1; i++) {
+    const current = tokens[i];
+    const next = tokens[i + 1];
+
+    if (current.type === 'literal' && !isOperatorToken(next)) {
+      const remaining = tokens.slice(i + 1);
+      const hasUnknownOperator =
+        remaining[0]?.type === 'variable' && remaining.some(isOperatorToken);
+
+      if (!hasUnknownOperator) {
+        const ignored = remaining.map((t) => t.value).join(' ');
+        const containsLogicalOperators = /&&|\|\|/.test(ignored);
+
+        if (containsLogicalOperators) {
+          return {
+            message: `Expression stops at truthy value '${current.value}', and will ignore: '${ignored}'. Use 'and'/'or' instead of '&&'/'||' for multiple conditions`,
+            fix: current.value,
+          };
+        } else {
+          return {
+            message: `Expression stops at truthy value '${current.value}', and will ignore: '${ignored}'`,
+            fix: current.value,
+          };
+        }
+      }
+    }
+  }
+  return null;
+}
+
+function analyzeConditionalExpression(markup: string): ExpressionIssue | null {
+  const trimmed = markup.trim();
+  if (!trimmed) return null;
+
+  const tokens: Token[] = getValuesInMarkup(trimmed).map(({ value }) => ({
+    value,
+    type: classifyToken(value),
+  }));
+
+  if (tokens.length === 0) return null;
+
+  return (
+    checkInvalidStartingToken(tokens) ||
+    checkTrailingTokensAfterComparison(tokens) ||
+    checkLaxParsingIssues(tokens)
+  );
+}

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

@@ -0,0 +1,52 @@
+import { expect, describe, it } from 'vitest';
+import { applyFix, runLiquidCheck } from '../../../test';
+import { LiquidHTMLSyntaxError } from '../index';
+
+describe('detectConditionalNodeUnsupportedParenthesis', async () => {
+  it('should not report no unsupported parenthesis in the markup', async () => {
+    const testCases = [`{% if condition %}{% endif %}`, `{% if range == (1..2) %}{% endif %}`];
+
+    for (const sourceCode of testCases) {
+      const offenses = await runLiquidCheck(LiquidHTMLSyntaxError, sourceCode);
+      expect(offenses).to.have.length(0);
+    }
+  });
+
+  it('should report when there are unsupported parenthesis in the markup', async () => {
+    const testCases = [
+      [
+        `{% if (this and that) or other %}{% endif %}`,
+        '{% if this and that or other %}{% endif %}',
+      ],
+      [`{% if (a > b) and (c == d) %}{% endif %}`, '{% if a > b and c == d %}{% endif %}'],
+    ];
+
+    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 report when there are multiple instances of the error', async () => {
+    const sourceCode = `{% if (a or c) %}{% endif %} {% if (a == b) %}{% endif %} {% if condition %}{% endif %}`;
+
+    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(
+      `{% if a or c %}{% endif %} {% if (a == b) %}{% endif %} {% if condition %}{% endif %}`,
+    );
+
+    const fixed2 = applyFix(sourceCode, offenses[1]);
+    expect(fixed2).to.equal(
+      `{% if (a or c) %}{% endif %} {% if a == b %}{% endif %} {% if condition %}{% endif %}`,
+    );
+  });
+});

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

@@ -0,0 +1,39 @@
+import { LiquidTag } from '@platformos/liquid-html-parser';
+import { SourceCodeType, Problem } from '../../..';
+import {
+  doesFragmentContainUnsupportedParentheses,
+  getFragmentsInMarkup,
+  INVALID_SYNTAX_MESSAGE,
+} from './utils';
+
+export function detectConditionalNodeUnsupportedParenthesis(
+  node: LiquidTag,
+): Problem<SourceCodeType.LiquidHtml> | undefined {
+  if (!['if', 'elsif', 'unless'].includes(node.name)) return;
+  if (typeof node.markup !== 'string' || !node.markup.trim()) return;
+
+  const markupIndex = node.source.indexOf(node.markup, node.position.start);
+
+  const fragments = getFragmentsInMarkup(node.markup);
+
+  const badFragments = fragments.filter((fragment) =>
+    doesFragmentContainUnsupportedParentheses(fragment.value),
+  );
+
+  if (badFragments.length) {
+    return {
+      message: INVALID_SYNTAX_MESSAGE,
+      startIndex: markupIndex,
+      endIndex: markupIndex + node.markup.length,
+      fix: (corrector) => {
+        for (const fragment of badFragments) {
+          corrector.replace(
+            markupIndex + fragment.index!,
+            markupIndex + fragment.index! + fragment.value.length,
+            fragment.value.replace(/[\(\)]/g, ''),
+          );
+        }
+      },
+    };
+  }
+}