Add support for ints and floats as numbers

grammar/liquid-html.ohm

@@ -109,11 +109,19 @@ LiquidHTML {
   // TODO
   liquidLiteral =
     | liquidString
+    | liquidNumber
 
   liquidString = liquidSingleQuotedString | liquidDoubleQuotedString
   liquidSingleQuotedString = "'" anyExceptStar<("'"| "%}" | "}}")> "'"
   liquidDoubleQuotedString = "\"" anyExceptStar<("\""| "%}" | "}}")> "\""
 
+  liquidNumber = liquidFloat | liquidInteger
+  liquidInteger = "-"? digit+
+
+  // This rule is funky (because of the possibility of many periods), but that's
+  // coming from shopify/liquid...
+  liquidFloat = "-"? digit (digit | ".")+
+
   // https://www.w3.org/TR/2011/WD-html-markup-20110113/syntax.html#void-element
   // Cheating a bit with by stretching it to the doctype
   voidElementName =

src/parser/ast.spec.ts

@@ -33,6 +33,27 @@ describe('Unit: toLiquidHtmlAST', () => {
         expectPosition(ast, 'children.0.markup.expression');
       });
     });
+
+    it('should parse numbers as LiquidVariable > Number', () => {
+      [
+        { expression: `1`, value: '1' },
+        { expression: `1.02`, value: '1.02' },
+        { expression: `0`, value: '0' },
+        { expression: `-0`, value: '-0' },
+        { expression: `-0.0`, value: '-0.0' },
+      ].forEach(({ expression, value }) => {
+        ast = toLiquidHtmlAST(`{{ ${expression} }}`);
+        expectPath(ast, 'children.0').to.exist;
+        expectPath(ast, 'children.0.type').to.eql('LiquidDrop');
+        expectPath(ast, 'children.0.markup.type').to.eql('LiquidVariable');
+        expectPath(ast, 'children.0.markup.rawSource').to.eql(expression);
+        expectPath(ast, 'children.0.markup.expression.type').to.eql('Number');
+        expectPath(ast, 'children.0.markup.expression.value').to.eql(value);
+        expectPosition(ast, 'children.0');
+        expectPosition(ast, 'children.0.markup');
+        expectPosition(ast, 'children.0.markup.expression');
+      });
+    });
   });
 
   it('should transform a basic Liquid Tag into a LiquidTag', () => {

src/parser/ast.ts

@@ -130,7 +130,7 @@ interface LiquidVariable extends ASTNode<NodeTypes.LiquidVariable> {
 }
 
 // TODO
-type LiquidExpression = LiquidString;
+type LiquidExpression = LiquidString | LiquidNumber;
 
 // TODO
 type LiquidFilter = undefined;
@@ -140,6 +140,10 @@ interface LiquidString extends ASTNode<NodeTypes.String> {
   value: string;
 }
 
+interface LiquidNumber extends ASTNode<NodeTypes.Number> {
+  value: string;
+}
+
 export type HtmlNode =
   | HtmlComment
   | HtmlElement
@@ -625,13 +629,28 @@ function toExpression(
   node: ConcreteLiquidExpression,
   source: string,
 ): LiquidExpression {
-  return {
-    type: NodeTypes.String,
-    position: position(node),
-    single: node.single,
-    value: node.value,
-    source,
-  };
+  switch (node.type) {
+    case ConcreteNodeTypes.String: {
+      return {
+        type: NodeTypes.String,
+        position: position(node),
+        single: node.single,
+        value: node.value,
+        source,
+      };
+    }
+    case ConcreteNodeTypes.Number: {
+      return {
+        type: NodeTypes.Number,
+        position: position(node),
+        value: node.value,
+        source,
+      };
+    }
+    default: {
+      return assertNever(node);
+    }
+  }
 }
 
 function toFilters(

src/parser/cst.spec.ts

@@ -176,6 +176,28 @@ describe('Unit: toLiquidHtmlCST(text)', () => {
         expectLocation(cst, '0.markup.expression');
       });
     });
+
+    it('should parse numbers', () => {
+      [
+        { expression: `1`, value: '1' },
+        { expression: `1.02`, value: '1.02' },
+        { expression: `0`, value: '0' },
+        { expression: `-0`, value: '-0' },
+        { expression: `-0.0`, value: '-0.0' },
+      ].forEach(({ expression, value }) => {
+        cst = toLiquidHtmlCST(`{{ ${expression} }}`);
+        expectPath(cst, '0.type').to.equal('LiquidDrop');
+        expectPath(cst, '0.markup.type').to.equal('LiquidVariable');
+        expectPath(cst, '0.markup.rawSource').to.equal(expression);
+        expectPath(cst, '0.markup.expression.type').to.equal('Number');
+        expectPath(cst, '0.markup.expression.value').to.equal(value);
+        expectPath(cst, '0.whitespaceStart').to.equal(null);
+        expectPath(cst, '0.whitespaceEnd').to.equal(null);
+        expectLocation(cst, '0');
+        expectLocation(cst, '0.markup');
+        expectLocation(cst, '0.markup.expression');
+      });
+    });
   });
 
   describe('Case: LiquidNode', () => {

src/parser/cst.ts

@@ -24,6 +24,7 @@ export enum ConcreteNodeTypes {
 
   LiquidVariable = 'LiquidVariable',
   String = 'String',
+  Number = 'Number',
 }
 
 export interface Parsers {
@@ -146,14 +147,21 @@ export interface ConcreteLiquidVariable
 export type ConcreteLiquidFilters = undefined; // TODO
 
 // TODO
-export type ConcreteLiquidExpression = ConcreteStringLiteral;
+export type ConcreteLiquidExpression =
+  | ConcreteStringLiteral
+  | ConcreteNumberLiteral;
 
 export interface ConcreteStringLiteral
   extends ConcreteBasicNode<ConcreteNodeTypes.String> {
   value: string;
   single: boolean;
 }
 
+export interface ConcreteNumberLiteral
+  extends ConcreteBasicNode<ConcreteNodeTypes.Number> {
+  value: string; // float parsing is weird but supported
+}
+
 export type ConcreteHtmlNode =
   | ConcreteHtmlComment
   | ConcreteHtmlRawTag
@@ -365,6 +373,13 @@ export function toLiquidHtmlCST(text: string): LiquidHtmlCST {
       locEnd,
     },
 
+    liquidNumber: {
+      type: ConcreteNodeTypes.Number,
+      value: 0,
+      locStart,
+      locEnd,
+    },
+
     liquidInlineComment: {
       type: ConcreteNodeTypes.LiquidTag,
       name: 3,

src/printer/preprocess/augment-with-css-properties.ts

@@ -82,6 +82,7 @@ function getCssDisplay(
 
     case NodeTypes.LiquidVariable:
     case NodeTypes.String:
+    case NodeTypes.Number:
       return 'should not be relevant';
 
     default:
@@ -128,6 +129,7 @@ function getNodeCssStyleWhiteSpace(node: AugmentedNode<WithSiblings>): string {
 
     case NodeTypes.LiquidVariable:
     case NodeTypes.String:
+    case NodeTypes.Number:
       return 'should not be relevant';
 
     default:

src/printer/printer-liquid-html.ts

@@ -386,6 +386,10 @@ function printNode(
       return [quote, node.value, quote];
     }
 
+    case NodeTypes.Number: {
+      return node.value;
+    }
+
     case NodeTypes.LiquidVariable: {
       // TODO this is where you'll do the pipe first/last logic.
       return [path.call(print, 'expression')];

src/types.ts

@@ -24,10 +24,10 @@ export enum NodeTypes {
   TextNode = 'TextNode',
 
   LiquidVariable = 'LiquidVariable',
-  VariableLookup = 'VariableLookup',
   String = 'String',
   Number = 'Number',
-  Range = 'Range',
+  // Range = 'Range',
+  // VariableLookup = 'VariableLookup',
 }
 
 export const HtmlNodeTypes = [

test/liquid-drop-number/fixed.liquid

@@ -0,0 +1,13 @@
+It should parse and print as numbers
+{{ -1 }}
+{{ -0 }}
+{{ 0 }}
+{{ 1 }}
+{{ -1.0 }}
+{{ -0.0 }}
+{{ 0.0 }}
+{{ 1.0 }}
+
+It should keep weird ass multi dots
+{{- 1.0.0 -}}
+{{- -1.0.0 -}}

test/liquid-drop-number/index.liquid

@@ -0,0 +1,13 @@
+It should parse and print as numbers
+{{ -1}}
+{{ -0}}
+{{0}}
+{{1}}
+{{ -1.0}}
+{{ -0.0}}
+{{0.0}}
+{{1.0}}
+
+It should keep weird ass multi dots
+{{- 1.0.0 -}}
+{{- -1.0.0 -}}

test/liquid-drop-number/index.spec.ts

@@ -0,0 +1,6 @@
+import { assertFormattedEqualsFixed } from '../test-helpers';
+import * as path from 'path';
+
+describe(`Unit: ${path.basename(__dirname)}`, () => {
+  assertFormattedEqualsFixed(__dirname);
+});