liquid2 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 396a11c43cb73cebe443927f69b83210d9c1651d9168ad7412726f54470492a7
-  data.tar.gz: ed127fb805a3862d3bde1db35dd88a713b714af3f65c51ba58d0f85fd09052c3
+  metadata.gz: 3a68d0ef0f934b9b4fd68d99591e5b0faf9df0e4d408e35c4df1aa2b7b98f4a1
+  data.tar.gz: 41d881fe5f30b1f390e2c8297e36ca08f6eb70c1b70225f8418ba255f6297759
 SHA512:
-  metadata.gz: 5c72bdc10c87b94b3863826cd1e964be714de2277c1c4627480fe0a9f869de977ae9efeb55cbaec573a625e43a46a0758312c36e15697d97934b177c968c078f
-  data.tar.gz: f2c6ec9e5d3d6d0fb86ba2455c0ec8134c8896243c6d8fab859ee3fbbd2c1bb17f2aaf949d591edf96eaf998d5562f7290e1ab9893502764ac9498ddb33aba97
+  metadata.gz: 53ad1737b2ae742366a0fc26e038c971d18a4f500ce104faac21a94547ac61a9926a5683a5150539e1b968d144b2cb15aa93823db163cbaa07d785b2e9ed3c31
+  data.tar.gz: 25e214ff840aacacb4ffed35160295d8fd7dd04ea301c62aec2a490d4c5d54ba72b73f9a7318b2bc0fb1f8c3ed7eea26a737ba5f8ea182b3a36e44996a8b06f4

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+## [0.3.1] - 25-06-24
+
+- Added support for custom markup delimiters. See [#16](https://github.com/jg-rp/ruby-liquid2/pull/16).
+- Added the `range` filter. `range` is an array slicing filter that takes optional start and end indexes, and an optional step argument, any of which can be negative. See [#18](https://github.com/jg-rp/ruby-liquid2/pull/18).
+
+## [0.3.0] - 25-05-29
+
+- Fixed static analysis of lambda expressions (arrow functions). Previously we were not including lambda parameters in the scope of the expression. See [#12](https://github.com/jg-rp/ruby-liquid2/issues/12).
+- Fixed parsing of variable paths that start with `true`, `false`, `nil` or `null`. For example, `{{ true.foo }}`. See [#13](https://github.com/jg-rp/ruby-liquid2/issues/13).
+- Added support for arithmetic infix operators `+`, `-`, `*`, `/`, `%` and `**`, and prefix operators `+` and `-`. These operators are disabled by default. Enable them by passing `arithmetic_operators: true` to a new `Liquid2::Environment`.
+
 ## [0.2.0] - 25-05-12
 
 - Fixed error context info when raising `UndefinedError` from `StrictUndefined`.

data/README.md

@@ -36,7 +36,7 @@ Liquid templates for Ruby, with some extra features.
 Add `'liquid2'` to your Gemfile:
 
 ```
-gem 'liquid2', '~> 0.2.0'
+gem 'liquid2', '~> 0.3.1'
 ```
 
 Or
@@ -219,6 +219,10 @@ Here we use `~` to remove the newline after the opening `for` tag, but preserve
 </ul>
 ```
 
+#### Arithmetic operators
+
+Arithmetic infix operators `+`, `-`, `*`, `/`, `%` and `**`, and prefix operators `+` and `-`, are an experimental feature and are disabled by default. Enable them by passing `arithmetic_operators: true` to a new [`Liquid2::Environment`](https://github.com/jg-rp/ruby-liquid2/blob/main/lib/liquid2/environment.rb).
+
 #### Scientific notation
 
 Integer and float literals can use scientific notation, like `1.2e3` or `1e-2`.
@@ -227,7 +231,13 @@ Integer and float literals can use scientific notation, like `1.2e3` or `1e-2`.
 
 Liquid2 includes implementations of `{% extends %}` and `{% block %}` for template inheritance, `{% with %}` for block scoped variables and `{% macro %}` and `{% call %}` for defining parameterized blocks.
 
-There's also built-in implementations of `sort_numeric` and `json` filters.
+The following filters are included in Liquid2's default environment:
+
+- `sort_numeric` - Sorts array elements by runs of digits found in their string representation.
+- `json` - Outputs objects serialized in JSON format.
+- `range`- An alternative to the standard `slice` filter that takes optional start and stop indexes, and an optional step, all of which can be negative.
+
+See [Tags and filters](#tags-and-filters) for how to add, remove or alias tags and/or filters from your own Liquid2 environment.
 
 ## API
 

data/lib/liquid2/environment.rb

@@ -38,14 +38,20 @@ require_relative "nodes/tags/with"
 module Liquid2
   # Template parsing and rendering configuration.
   #
-  # A Liquid::Environment is where you might register custom tags and filters,
+  # A Liquid2::Environment is where you might register custom tags and filters,
   # or store global context data that should be available to all templates.
   #
   # `Liquid2.parse(source)` is equivalent to `Liquid2::Environment.new.parse(source)`.
   class Environment
     attr_reader :tags, :local_namespace_limit, :context_depth_limit, :loop_iteration_limit,
                 :output_stream_limit, :filters, :suppress_blank_control_flow_blocks,
-                :shorthand_indexes, :falsy_undefined
+                :shorthand_indexes, :falsy_undefined, :arithmetic_operators, :markup_comment_prefix,
+                :markup_comment_suffix, :markup_out_end, :markup_out_start, :markup_tag_end,
+                :markup_tag_start, :re_tag_name, :re_word, :re_int, :re_float,
+                :re_double_quote_string_special, :re_single_quote_string_special, :re_markup_start,
+                :re_markup_end, :re_markup_end_chars, :re_up_to_markup_start, :re_punctuation,
+                :re_up_to_inline_comment_end, :re_up_to_raw_end, :re_block_comment_chunk,
+                :re_up_to_doc_end, :re_line_statement_comment
 
     # @param context_depth_limit [Integer] The maximum number of times a render context can
     #   be extended or copied before a `Liquid2::LiquidResourceLimitError`` is raised.
@@ -59,8 +65,23 @@ module Liquid2
     #   `Liquid2::LiquidResourceLimitError`` is raised.
     # @param loop_iteration_limit [Integer?] The maximum number of loop iterations allowed
     #   before a `LiquidResourceLimitError` is raised.
+    # @param markup_comment_prefix [String] The string of characters that indicate the start of a
+    #   Liquid comment. This should include a single trailing `#`. Additional, variable length
+    #   hashes will be handled by the tokenizer. It is not possible to change comment syntax to not
+    #   use `#`.
+    # @param markup_comment_suffix [String] The string of characters that indicate the end of a
+    #   Liquid comment, excluding any hashes.
+    # @param markup_out_end [String] The string of characters that indicate the end of a Liquid
+    #   output statement.
+    # @param markup_out_start [String] The string of characters that indicate the start of a Liquid
+    #   output statement.
+    # @param markup_tag_end [String] The string of characters that indicate the end of a Liquid tag.
+    # @param markup_tag_start [String] The string of characters that indicate the start of a Liquid
+    #   tag.
     # @param output_stream_limit [Integer?] The maximum number of bytes that can be written
     #   to a template's output buffer before a `LiquidResourceLimitError` is raised.
+    # @param parser [singleton(Parser)] `Liquid2::Parser` or a subclass of it.
+    # @param scanner [singleton(Scanner)] `Liquid2::Scanner` or a subclass of it.
     # @param shorthand_indexes [bool] When `true`, allow shorthand dotted array indexes as
     #   well as bracketed indexes in variable paths. Defaults to `false`.
     # @param suppress_blank_control_flow_blocks [bool] When `true`, suppress blank control
@@ -68,16 +89,25 @@ module Liquid2
     # @param undefined [singleton(Liquid2::Undefined)] A singleton returning an instance of
     #   `Liquid2::Undefined`, which is used to represent template variables that don't exist.
     def initialize(
+      arithmetic_operators: false,
       context_depth_limit: 30,
+      falsy_undefined: true,
       globals: nil,
       loader: nil,
       local_namespace_limit: nil,
       loop_iteration_limit: nil,
+      markup_comment_prefix: "{#",
+      markup_comment_suffix: "}",
+      markup_out_end: "}}",
+      markup_out_start: "{{",
+      markup_tag_end: "%}",
+      markup_tag_start: "{%",
       output_stream_limit: nil,
+      parser: Parser,
+      scanner: Scanner,
       shorthand_indexes: false,
       suppress_blank_control_flow_blocks: true,
-      undefined: Undefined,
-      falsy_undefined: true
+      undefined: Undefined
     )
       # A mapping of tag names to objects responding to `parse(token, parser)`.
       @tags = {}
@@ -87,6 +117,10 @@ module Liquid2
       # keyword argument.
       @filters = {}
 
+      # When `true`, arithmetic operators `+`, `-`, `*`, `/`, `%` and `**` are enabled.
+      # Defaults to `false`.
+      @arithmetic_operators = arithmetic_operators
+
       # The maximum number of times a render context can be extended or copied before
       # a Liquid2::LiquidResourceLimitError is raised.
       @context_depth_limit = context_depth_limit
@@ -111,9 +145,17 @@ module Liquid2
       # before a `LiquidResourceLimitError` is raised.
       @output_stream_limit = output_stream_limit
 
+      # Liquid2::Scanner or a subclass of it. This is used to tokenize Liquid source
+      # text before parsing it.
+      @scanner = scanner
+
+      # Liquid2::Parser or a subclass of it. The parser takes tokens from the scanner
+      # and produces an abstract syntax tree.
+      @parser = parser
+
       # We reuse the same string scanner when parsing templates for improved performance.
       # TODO: Is this going to cause issues in multi threaded environments?
-      @scanner = StringScanner.new("")
+      @string_scanner = StringScanner.new("")
 
       # When `true`, allow shorthand dotted array indexes as well as bracketed indexes
       # in variable paths. Defaults to `false`.
@@ -131,6 +173,31 @@ module Liquid2
       # raise an error when tested for truthiness.
       @falsy_undefined = falsy_undefined
 
+      # The string of characters that indicate the start of a Liquid output statement.
+      @markup_out_start = markup_out_start
+
+      # The string of characters that indicate the end of a Liquid output statement.
+      @markup_out_end = markup_out_end
+
+      # The string of characters that indicate the start of a Liquid tag.
+      @markup_tag_start = markup_tag_start
+
+      # The string of characters that indicate the end of a Liquid tag.
+      @markup_tag_end = markup_tag_end
+
+      # The string of characters that indicate the start of a Liquid comment. This should
+      # include a single trailing `#`. Additional, variable length hashes will be handled
+      # by the tokenizer. It is not possible to change comment syntax to not use `#`.
+      @markup_comment_prefix = markup_comment_prefix
+
+      # The string of characters that indicate the end of a Liquid comment, excluding any
+      # hashes.
+      @markup_comment_suffix = markup_comment_suffix
+
+      # You might need to override `setup_scanner` if you've specified custom markup
+      # delimiters and they conflict with standard punctuation.
+      setup_scanner
+
       # Override `setup_tags_and_filters` in environment subclasses to configure custom
       # tags and/or filters.
       setup_tags_and_filters
@@ -140,11 +207,13 @@ module Liquid2
     # @param source [String] template source text.
     # @return [Template]
     def parse(source, name: "", path: nil, up_to_date: nil, globals: nil, overlay: nil)
-      Template.new(self,
-                   source,
-                   Parser.parse(self, source, scanner: @scanner),
-                   name: name, path: path, up_to_date: up_to_date,
-                   globals: make_globals(globals), overlay: overlay)
+      Template.new(
+        self,
+        source,
+        @parser.new(self, @scanner.tokenize(self, source, @string_scanner), source.length).parse,
+        name: name, path: path, up_to_date: up_to_date,
+        globals: make_globals(globals), overlay: overlay
+      )
     rescue LiquidError => e
       e.source = source unless e.source
       e.template_name = name unless e.template_name || name.empty?
@@ -257,6 +326,7 @@ module Liquid2
       register_filter("newline_to_br", Liquid2::Filters.method(:newline_to_br))
       register_filter("plus", Liquid2::Filters.method(:plus))
       register_filter("prepend", Liquid2::Filters.method(:prepend))
+      register_filter("range", Liquid2::Filters.method(:better_slice))
       register_filter("reject", Liquid2::Filters.method(:reject))
       register_filter("remove_first", Liquid2::Filters.method(:remove_first))
       register_filter("remove_last", Liquid2::Filters.method(:remove_last))
@@ -287,6 +357,51 @@ module Liquid2
       register_filter("where", Liquid2::Filters.method(:where))
     end
 
+    # Compile regular expressions for use by the tokenizer attached to this environment.
+    def setup_scanner
+      # A regex pattern matching Liquid tag names. Should include `#` for inline comments.
+      @re_tag_name = /(?:[a-z][a-z_0-9]*|#)/
+
+      # A regex pattern matching keywords and/or variable/path names. Replace this if
+      # you want to disable Unicode characters in identifiers, for example.
+      @re_word = /[\u0080-\uFFFFa-zA-Z_][\u0080-\uFFFFa-zA-Z0-9_-]*/
+
+      # Patterns matching literal integers and floats, possibly in scientific notation.
+      # You could simplify these to disable scientific notation.
+      @re_int = /-?\d+(?:[eE]\+?\d+)?/
+      @re_float = /((?:-?\d+\.\d+(?:[eE][+-]?\d+)?)|(-?\d+[eE]-\d+))/
+
+      # Patterns matching escape sequences, interpolation and end of string in string literals.
+      # You could remove `\$` from these to disable string interpolation.
+      @re_double_quote_string_special = /[\\"\$]/
+      @re_single_quote_string_special = /[\\'\$]/
+
+      # rubocop: disable Layout/LineLength
+
+      # A regex pattern matching the start of some Liquid markup. Could be the start of an
+      # output statement, tag or comment. Traditionally `{{`, `{%` and `{#`, respectively.
+      @re_markup_start = /#{Regexp.escape(@markup_out_start)}|#{Regexp.escape(@markup_tag_start)}|#{Regexp.escape(@markup_comment_prefix)}/
+
+      # A regex pattern matching the end of some Liquid markup. Could be the end of
+      # an output statement or tag. Traditionally `}}`, `%}`, respectively.
+      @re_markup_end = /#{Regexp.escape(@markup_out_end)}|#{Regexp.escape(@markup_tag_end)}/
+
+      # A regex pattern matching any one of the possible characters ending some Liquid
+      # markup. This is used to detect incomplete and malformed markup and provide
+      # helpful error messages.
+      @re_markup_end_chars = /[#{Regexp.escape((@markup_out_end + @markup_tag_end).each_char.uniq.join)}]/
+
+      @re_up_to_markup_start = /(?=#{Regexp.escape(@markup_out_start)}|#{Regexp.escape(@markup_tag_start)}|#{Regexp.escape(@markup_comment_prefix)})/
+      @re_punctuation = %r{(?!#{@re_markup_end})(\?|\[|\]|\|{1,2}|\.{1,2}|,|:|\(|\)|[<>=!]+|[+\-%*/]+(?!#{@re_markup_end_chars}))}
+      @re_up_to_inline_comment_end = /(?=([+\-~])?#{Regexp.escape(@markup_tag_end)})/
+      @re_up_to_raw_end = /(?=(#{Regexp.escape(@markup_tag_start)}[+\-~]?\s*endraw\s*[+\-~]?#{Regexp.escape(@markup_tag_end)}))/
+      @re_block_comment_chunk = /(#{Regexp.escape(@markup_tag_start)}[+\-~]?\s*(comment|raw|endcomment|endraw)\s*[+\-~]?#{Regexp.escape(@markup_tag_end)})/
+      @re_up_to_doc_end = /(?=(#{Regexp.escape(@markup_tag_start)}[+\-~]?\s*enddoc\s*[+\-~]?#{Regexp.escape(@markup_tag_end)}))/
+      @re_line_statement_comment = /(?=([\r\n]+|-?#{Regexp.escape(@markup_tag_end)}))/
+
+      # rubocop: enable Layout/LineLength
+    end
+
     def undefined(name, node: nil)
       @undefined.new(name, node: node)
     end

data/lib/liquid2/expressions/arithmetic.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require_relative "blank"
+require_relative "../expression"
+
+module Liquid2 # :nodoc:
+  # Base class for all arithmetic expressions.
+  class ArithmeticExpression < Expression
+    # @param left [Expression]
+    # @param right [Expression]
+    def initialize(token, left, right)
+      super(token)
+      @left = left
+      @right = right
+    end
+
+    def children = [@left, @right]
+
+    protected
+
+    def inner_evaluate(context)
+      left = context.evaluate(@left)
+      right = context.evaluate(@right)
+      left = left.to_liquid(context) if left.respond_to?(:to_liquid)
+      right = right.to_liquid(context) if right.respond_to?(:to_liquid)
+      [Liquid2::Filters.to_decimal(left), Liquid2::Filters.to_decimal(right)]
+    end
+  end
+
+  # Infix addition
+  class Plus < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left + right
+    end
+  end
+
+  # Infix subtraction
+  class Minus < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left - right
+    end
+  end
+
+  # Infix multiplication
+  class Times < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left * right
+    end
+  end
+
+  # Infix division
+  class Divide < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left / right
+    rescue ZeroDivisionError => e
+      raise LiquidTypeError.new(e.message, nil)
+    end
+  end
+
+  # Infix modulo
+  class Modulo < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left % right
+    rescue ZeroDivisionError => e
+      raise LiquidTypeError.new(e.message, nil)
+    end
+  end
+
+  # Infix exponentiation
+  class Pow < ArithmeticExpression
+    def evaluate(context)
+      left, right = inner_evaluate(context)
+      left**right
+    end
+  end
+
+  # Prefix negation
+  class Negative < Expression
+    # @param right [Expression]
+    def initialize(token, right)
+      super(token)
+      @right = right
+    end
+
+    def evaluate(context)
+      right = context.evaluate(@right)
+      value = Liquid2::Filters.to_decimal(right,
+                                          default: nil) || context.env.undefined(
+                                            "-(#{Liquid2.to_output_string(right)})",
+                                            node: self
+                                          )
+      value.send(:-@)
+    end
+
+    def children = [@right]
+  end
+
+  # Prefix positive
+  class Positive < Expression
+    # @param right [Expression]
+    def initialize(token, right)
+      super(token)
+      @right = right
+    end
+
+    def evaluate(context)
+      right = context.evaluate(@right)
+      value = Liquid2::Filters.to_decimal(right,
+                                          default: nil) || context.env.undefined(
+                                            "+(#{Liquid2.to_output_string(right)})",
+                                            node: self
+                                          )
+      value.send(:+@)
+    end
+
+    def children = [@right]
+  end
+end

data/lib/liquid2/expressions/lambda.rb

@@ -19,6 +19,8 @@ module Liquid2
 
     def children = [@expr]
 
+    def scope = @params
+
     # Apply this lambda function to elements from _enum_.
     # @param context [RenderContext]
     # @param enum [Enumerable<Object>]

data/lib/liquid2/expressions/relational.rb

@@ -4,7 +4,7 @@ require_relative "blank"
 require_relative "../expression"
 
 module Liquid2 # :nodoc:
-  # Base for comparison expressions.
+  # Base class for all comparison expressions.
   class ComparisonExpression < Expression
     # @param left [Expression]
     # @param right [Expression]

data/lib/liquid2/filters/slice.rb

@@ -13,5 +13,45 @@ module Liquid2
         Liquid2.to_s(left).slice(to_integer(start), to_integer(length)) || ""
       end
     end
+
+    def self.better_slice(
+      left,
+      start_ = :undefined, stop_ = :undefined, step_ = :undefined,
+      start: :undefined, stop: :undefined, step: :undefined
+    )
+      # Give priority to keyword arguments, default to nil if neither are given.
+      start = start_ == :undefined ? nil : start_ if start == :undefined
+      stop = stop_ == :undefined ? nil : stop_ if stop == :undefined
+      step = step_ == :undefined ? nil : step_ if step == :undefined
+
+      step = to_integer(step || 1)
+      length = left.length
+      return [] if length.zero? || step.zero?
+
+      start = to_integer(start) unless start.nil?
+      stop = to_integer(stop) unless stop.nil?
+
+      normalized_start = if start.nil?
+                           step.negative? ? length - 1 : 0
+                         elsif start&.negative?
+                           [length + start, 0].max
+                         else
+                           [start, length - 1].min
+                         end
+
+      normalized_stop = if stop.nil?
+                          step.negative? ? -1 : length
+                        elsif stop&.negative?
+                          [length + stop, -1].max
+                        else
+                          [stop, length].min
+                        end
+
+      # This does not work with Ruby 3.1
+      # left[(normalized_start...normalized_stop).step(step)]
+      #
+      # But this does.
+      (normalized_start...normalized_stop).step(step).map { |i| left[i] }
+    end
   end
 end

data/lib/liquid2/nodes/tags/raw.rb

@@ -10,7 +10,8 @@ module Liquid2
     def self.parse(token, parser)
       parser.carry_whitespace_control
       parser.eat(:token_tag_end)
-      # TODO: apply whitespace control to raw text
+      # TODO: apply whitespace control to raw text?
+      # Shopify/liquid does not apply whitespace control to raw content.
       raw = parser.eat(:token_raw)
       parser.eat_empty_tag("endraw")
       new(token, raw[1] || raise)

data/lib/liquid2/parser.rb

@@ -7,6 +7,7 @@ require_relative "node"
 require_relative "nodes/comment"
 require_relative "nodes/output"
 require_relative "expressions/arguments"
+require_relative "expressions/arithmetic"
 require_relative "expressions/array"
 require_relative "expressions/blank"
 require_relative "expressions/boolean"
@@ -24,11 +25,12 @@ module Liquid2
   # Liquid template parser.
   class Parser
     # Parse Liquid template text into a syntax tree.
+    # @param env [Environment]
     # @param source [String]
     # @return [Array[Node | String]]
     def self.parse(env, source, scanner: nil)
       new(env,
-          Liquid2::Scanner.tokenize(source, scanner || StringScanner.new("")),
+          Liquid2::Scanner.tokenize(env, source, scanner || StringScanner.new("")),
           source.length).parse
     end
 
@@ -336,14 +338,26 @@ module Liquid2
 
       left = case kind
              when :token_true
-               self.next
-               looks_like_a_path ? parse_path : true
+               if looks_like_a_path
+                 parse_path
+               else
+                 self.next
+                 true
+               end
              when :token_false
-               self.next
-               looks_like_a_path ? parse_path : false
+               if looks_like_a_path
+                 parse_path
+               else
+                 self.next
+                 false
+               end
              when :token_nil
-               self.next
-               looks_like_a_path ? parse_path : nil
+               if looks_like_a_path
+                 parse_path
+               else
+                 self.next
+                 nil
+               end
              when :token_int
                Liquid2.to_liquid_int(self.next[1])
              when :token_float
@@ -358,7 +372,7 @@ module Liquid2
                parse_path
              when :token_lparen
                parse_range_lambda_or_grouped_expression
-             when :token_not
+             when :token_not, :token_plus, :token_minus
                parse_prefix_expression
              else
                unless looks_like_a_path && RESERVED_WORDS.include?(kind)
@@ -535,7 +549,10 @@ module Liquid2
       LOGICAL_AND = 4
       RELATIONAL = 5
       MEMBERSHIP = 6
-      PREFIX = 7
+      ADD_SUB = 8
+      MUL_DIV = 9
+      POW = 10
+      PREFIX = 11
     end
 
     PRECEDENCES = {
@@ -551,7 +568,14 @@ module Liquid2
       token_ne: Precedence::RELATIONAL,
       token_lg: Precedence::RELATIONAL,
       token_le: Precedence::RELATIONAL,
-      token_ge: Precedence::RELATIONAL
+      token_ge: Precedence::RELATIONAL,
+      token_plus: Precedence::ADD_SUB,
+      token_minus: Precedence::ADD_SUB,
+      token_times: Precedence::MUL_DIV,
+      token_divide: Precedence::MUL_DIV,
+      token_floor_div: Precedence::MUL_DIV,
+      token_mod: Precedence::MUL_DIV,
+      token_pow: Precedence::POW
     }.freeze
 
     BINARY_OPERATORS = Set[
@@ -565,7 +589,14 @@ module Liquid2
       :token_contains,
       :token_in,
       :token_and,
-      :token_or
+      :token_or,
+      :token_plus,
+      :token_minus,
+      :token_times,
+      :token_divide,
+      :token_floor_div,
+      :token_mod,
+      :token_pow
     ]
 
     TERMINATE_EXPRESSION = Set[
@@ -794,23 +825,36 @@ module Liquid2
         return parse_partial_arrow_function(expr)
       end
 
-      unless TERMINATE_GROUPED_EXPRESSION.member?(kind)
-        unless BINARY_OPERATORS.member?(kind)
-          raise LiquidSyntaxError.new("expected an infix operator, found #{kind}", current)
-        end
-
-        expr = parse_infix_expression(expr)
-      end
-
-      eat(:token_rparen)
-      GroupedExpression.new(token, expr)
+      eat(:token_rparen, "unbalanced parentheses")
+      expr
     end
 
     # @return [Node]
     def parse_prefix_expression
-      token = eat(:token_not)
-      expr = parse_primary
-      LogicalNot.new(token, expr)
+      case current_kind
+      when :token_not
+        token = self.next
+        expr = parse_primary(precedence: Precedence::PREFIX)
+        LogicalNot.new(token, expr)
+      when :token_plus
+        token = self.next
+        unless @env.arithmetic_operators
+          raise LiquidSyntaxError.new("unexpected prefix operator +",
+                                      token)
+        end
+
+        Positive.new(token, parse_primary(precedence: Precedence::PREFIX))
+      when :token_minus
+        token = self.next
+        unless @env.arithmetic_operators
+          raise LiquidSyntaxError.new("unexpected prefix operator -",
+                                      token)
+        end
+
+        Negative.new(token, parse_primary(precedence: Precedence::PREFIX))
+      else
+        raise LiquidSyntaxError.new("unexpected prefix operator #{current[1]}", current)
+      end
     end
 
     # @param left [Expression]
@@ -842,7 +886,27 @@ module Liquid2
       when :token_or
         LogicalOr.new(op_token, left, right)
       else
-        raise LiquidSyntaxError.new("unexpected infix operator, #{op_token[1]}", op_token)
+        unless @env.arithmetic_operators
+          raise LiquidSyntaxError.new("unexpected infix operator, #{op_token[1]}",
+                                      op_token)
+        end
+
+        case op_token.first
+        when :token_plus
+          Plus.new(op_token, left, right)
+        when :token_minus
+          Minus.new(op_token, left, right)
+        when :token_times
+          Times.new(op_token, left, right)
+        when :token_divide
+          Divide.new(op_token, left, right)
+        when :token_mod
+          Modulo.new(op_token, left, right)
+        when :token_pow
+          Pow.new(op_token, left, right)
+        else
+          raise LiquidSyntaxError.new("unexpected infix operator, #{op_token[1]}", op_token)
+        end
       end
     end