Update ruby/setup-ruby from v1.273.0 to v1.295.0

The pinned version (v1.273.0) does not have prebuilt `ruby-head` binaries
for `ubuntu-24.04`, which `ubuntu-latest` now resolves to. This causes CI
to fail with "Unavailable version head for ruby on ubuntu-24.04".

Updating to v1.295.0 picks up ubuntu-24.04 support for all Ruby versions
including head builds.

Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>

.github/workflows/liquid.yml

@@ -35,7 +35,7 @@ jobs:
     name: Test Ruby ${{ matrix.entry.ruby }} ${{ matrix.entry.rubyopt }} --${{ matrix.entry.allowed-failure && 'allowed-failure' || 'strict' }}
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
+      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
         with:
           ruby-version: ${{ matrix.entry.ruby }}
           bundler-cache: true
@@ -51,18 +51,22 @@ jobs:
       BUNDLE_WITH: spec
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
+      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
         with:
           bundler-cache: true
           bundler: latest
       - name: Run liquid-spec for all adapters
-        run: bin/liquid-spec-all-adapters
+        run: |
+          for adapter in spec/*.rb; do
+            echo "=== Running $adapter ==="
+            bundle exec liquid-spec run "$adapter" --no-max-failures
+          done
 
   memory_profile:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
+      - uses: ruby/setup-ruby@319994f95fa847cf3fb3cd3dbe89f6dcde9f178f # v1.295.0
         with:
           bundler-cache: true
       - run: bundle exec rake memory_profile:run

Gemfile

@@ -32,7 +32,6 @@ group :test do
 end
 
 group :spec do
-  # TODO: temporary - using cp-gate-lax-specs-ai branch until lax specs are properly gated
-  gem 'liquid-spec', github: 'Shopify/liquid-spec', branch: 'cp-gate-lax-specs-ai'
+  gem 'liquid-spec', github: 'Shopify/liquid-spec', branch: 'main'
   gem 'activesupport', require: false
 end

History.md

@@ -1,55 +1,5 @@
 # Liquid Change Log
 
-## 6.0.0
-
-### Features
-* Add support for boolean expressions everywhere
-  * As variable output `{{ a or b }}`
-  * As filter argument `{{ collection | where: 'prop', a or b }}`
-  * As tag argument `{% render 'snip', enabled: a or b %}`
-  * As conditional tag argument `{% if cond %}` (extending previous behaviour)
-* Add support for subexpression prioritization and associativity
-  * In ascending order of priority:
-    * Logical: `and`, `or` (right to left)
-    * Equality: `==`, `!=`, `<>` (left to right)
-    * Comparison: `>`, `>=`, `<`, `<=`, `contains` (left to right)
-    * Groupings: `( expr )`
-  - For example, this is now supported
-    * `{{ a > b == c < d or e == f }}` which is equivalent to
-    * `{{ ((a > b) == (c < d)) or (e == f) }}`
-- Add support for parenthesized expressions
-  * e.g. `(a or b) == c`
-
-### Architectural changes
-* `parse_expression` and `safe_parse_expression` have been removed from `Tag` and `ParseContext`
-* `Parser` methods now produce AST nodes instead of strings
-  * `Parser#expression` produces a value,
-  * `Parser#string` produces a string,
-  * etc.
-
-### Breaking changes
-* The Environment's `error_mode` option has been removed.
-  * `:warn` is no longer supported
-  * `:lax` and `lax_parse` is no longer supported
-  * `:strict` and `strict_parse` is no longer supported
-  * `strict2_parse` is renamed to `parse_markup`
-* Expressions
-  * The `warnings` system has been removed.
-  * `Parser#expression` is renamed to `Parser#expression_string`
-  * `safe_parse_expression` methods are replaced by `Parser#expression`
-  * `parse_expression` methods are replaced by `Parser#unsafe_parse_expression`
-* `Condition`
-  * `new(expr)` no longer accepts an `op` or `right`. Logic moved to BinaryExpression.
-  * `Condition#or` and `Condition#and` were replaced by `BinaryExpression`.
-  * `Condition#child_relation` replaced by `BinaryExpression`.
-  * `Condition.operations` was removed.
-  * `Condtion::MethodLiteral` was moved to the `Liquid` namespace
-
-### Migrating from `^5.11.0`
-- In custom tags that include `ParserSwitching`, rename `strict2_parse` to `parse_markup`
-- Remove code depending on `:error_mode`
-- Replace `safe_parse_expression` calls with `Parser#expression`
-
 ## 5.11.0
 * Revert the Inline Snippets tag (#2001), treat its inclusion in the latest Liquid release as a bug, and allow for feedback on RFC#1916 to better support Liquid developers [Guilherme Carreiro]
 * Rename the `:rigid` error mode to `:strict2` and display a warning when users attempt to use the `:rigid` mode [Guilherme Carreiro]

README.md

@@ -93,6 +93,31 @@ LIQUID
 
 By using Environments, you ensure that custom tags and filters are only available in the contexts where they are needed, making your Liquid templates more robust and easier to manage. For smaller projects, a global environment is available via `Liquid::Environment.default`.
 
+### Error Modes
+
+Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
+Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
+it very hard to debug and can lead to unexpected behaviour.
+
+Liquid also comes with different parsers that can be used when editing templates to give better error messages
+when templates are invalid. You can enable this new parser like this:
+
+```ruby
+Liquid::Environment.default.error_mode = :strict2 # Raises a SyntaxError when invalid syntax is used in all tags
+Liquid::Environment.default.error_mode = :strict  # Raises a SyntaxError when invalid syntax is used in some tags
+Liquid::Environment.default.error_mode = :warn    # Adds strict errors to template.errors but continues as normal
+Liquid::Environment.default.error_mode = :lax     # The default mode, accepts almost anything.
+```
+
+If you want to set the error mode only on specific templates you can pass `:error_mode` as an option to `parse`:
+```ruby
+Liquid::Template.parse(source, error_mode: :strict)
+```
+This is useful for doing things like enabling strict mode only in the theme editor.
+
+It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
+It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
+
 ### Undefined variables and filters
 
 By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.

Rakefile

@@ -33,12 +33,29 @@ task :rubocop do
   end
 end
 
-desc('runs test suite')
+desc('runs test suite with lax, strict, and strict2 parsers')
 task :test do
+  ENV['LIQUID_PARSER_MODE'] = 'lax'
+  Rake::Task['base_test'].invoke
+
+  ENV['LIQUID_PARSER_MODE'] = 'strict'
+  Rake::Task['base_test'].reenable
+  Rake::Task['base_test'].invoke
+
+  ENV['LIQUID_PARSER_MODE'] = 'strict2'
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
   if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
+    ENV['LIQUID_PARSER_MODE'] = 'lax'
+    Rake::Task['integration_test'].reenable
+    Rake::Task['integration_test'].invoke
+
+    ENV['LIQUID_PARSER_MODE'] = 'strict'
+    Rake::Task['integration_test'].reenable
+    Rake::Task['integration_test'].invoke
+
+    ENV['LIQUID_PARSER_MODE'] = 'strict2'
     Rake::Task['integration_test'].reenable
     Rake::Task['integration_test'].invoke
   end
@@ -61,11 +78,24 @@ task release: :build do
 end
 
 namespace :benchmark do
-  desc "Run the liquid benchmark"
-  task :run do
-    ruby "./performance/benchmark.rb"
+  desc "Run the liquid benchmark with lax parsing"
+  task :lax do
+    ruby "./performance/benchmark.rb lax"
   end
 
+  desc "Run the liquid benchmark with strict parsing"
+  task :strict do
+    ruby "./performance/benchmark.rb strict"
+  end
+
+  desc "Run the liquid benchmark with strict2 parsing"
+  task :strict2 do
+    ruby "./performance/benchmark.rb strict2"
+  end
+
+  desc "Run the liquid benchmark with lax, strict, and strict2 parsing"
+  task run: [:lax, :strict, :strict2]
+
   desc "Run unit benchmarks"
   namespace :unit do
     task :all do
@@ -96,6 +126,11 @@ namespace :profile do
   task :run do
     ruby "./performance/profile.rb"
   end
+
+  desc "Run the liquid profile/performance coverage with strict parsing"
+  task :strict do
+    ruby "./performance/profile.rb strict"
+  end
 end
 
 namespace :memory_profile do

bin/liquid-spec-all-adapters

@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-for adapter in spec/*.rb; do
-  echo "=== Running $adapter ==="
-  bundle exec liquid-spec run "$adapter" --no-max-failures
-done

lib/liquid.rb

@@ -62,8 +62,6 @@ require 'liquid/interrupts'
 require 'liquid/tags'
 require "liquid/environment"
 require 'liquid/lexer'
-require 'liquid/method_literal'
-require 'liquid/binary_expression'
 require 'liquid/parser'
 require 'liquid/i18n'
 require 'liquid/drop'

lib/liquid/binary_expression.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class BinaryExpression
-    attr_reader :operator
-    attr_accessor :left_node, :right_node
-
-    def initialize(left, operator, right)
-      @left_node = left
-      @operator = operator
-      @right_node = right
-    end
-
-    def evaluate(context)
-      left = value(left_node, context)
-
-      # logical relation short circuiting
-      if operator == 'and'
-        return left && value(right_node, context)
-      elsif operator == 'or'
-        return left || value(right_node, context)
-      end
-
-      right = value(right_node, context)
-
-      case operator
-      when '>'
-        left > right if can_compare?(left, right)
-      when '>='
-        left >= right if can_compare?(left, right)
-      when '<'
-        left < right if can_compare?(left, right)
-      when '<='
-        left <= right if can_compare?(left, right)
-      when '=='
-        equal_variables(left, right)
-      when '!=', '<>'
-        !equal_variables(left, right)
-      when 'contains'
-        contains(left, right)
-      else
-        raise(Liquid::ArgumentError, "Unknown operator #{operator}")
-      end
-    rescue ::ArgumentError => e
-      raise Liquid::ArgumentError, e.message
-    end
-
-    def to_s
-      "(#{left_node.inspect} #{operator} #{right_node.inspect})"
-    end
-
-    private
-
-    def value(expr, context)
-      Utils.to_liquid_value(context.evaluate(expr))
-    end
-
-    def can_compare?(left, right)
-      left.respond_to?(operator) && right.respond_to?(operator) && !left.is_a?(Hash) && !right.is_a?(Hash)
-    end
-
-    def contains(left, right)
-      if left && right && left.respond_to?(:include?)
-        right = right.to_s if left.is_a?(String)
-        left.include?(right)
-      else
-        false
-      end
-    rescue Encoding::CompatibilityError
-      # "✅".b.include?("✅") raises Encoding::CompatibilityError despite being materially equal
-      left.b.include?(right.b)
-    end
-
-    def apply_method_literal(node, other)
-      node.apply(other)
-    end
-
-    def equal_variables(left, right)
-      return apply_method_literal(left, right) if left.is_a?(MethodLiteral)
-      return apply_method_literal(right, left) if right.is_a?(MethodLiteral)
-
-      left == right
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.left_node,
-          @node.right_node,
-        ]
-      end
-    end
-  end
-end

lib/liquid/condition.rb

@@ -5,19 +5,92 @@ module Liquid
   #
   # Example:
   #
-  #   c = Condition.new(expr)
+  #   c = Condition.new(1, '==', 1)
   #   c.evaluate #=> true
   #
   class Condition # :nodoc:
-    attr_reader :attachment
-    attr_accessor :left
+    @@operators = {
+      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<' => :<,
+      '>' => :>,
+      '>=' => :>=,
+      '<=' => :<=,
+      'contains' => lambda do |_cond, left, right|
+        if left && right && left.respond_to?(:include?)
+          right = right.to_s if left.is_a?(String)
+          left.include?(right)
+        else
+          false
+        end
+      rescue Encoding::CompatibilityError
+        # "✅".b.include?("✅") raises Encoding::CompatibilityError despite being materially equal
+        left.b.include?(right.b)
+      end,
+    }
 
-    def initialize(left = nil)
-      @left = left
+    class MethodLiteral
+      attr_reader :method_name, :to_s
+
+      def initialize(method_name, to_s)
+        @method_name = method_name
+        @to_s = to_s
+      end
+    end
+
+    @@method_literals = {
+      'blank' => MethodLiteral.new(:blank?, '').freeze,
+      'empty' => MethodLiteral.new(:empty?, '').freeze,
+    }
+
+    def self.operators
+      @@operators
+    end
+
+    def self.parse_expression(parse_context, markup, safe: false)
+      @@method_literals[markup] || parse_context.parse_expression(markup, safe: safe)
+    end
+
+    attr_reader :attachment, :child_condition
+    attr_accessor :left, :operator, :right
+
+    def initialize(left = nil, operator = nil, right = nil)
+      @left     = left
+      @operator = operator
+      @right    = right
+
+      @child_relation  = nil
+      @child_condition = nil
     end
 
     def evaluate(context = deprecated_default_context)
-      context.evaluate(left)
+      condition = self
+      result = nil
+      loop do
+        result = interpret_condition(condition.left, condition.right, condition.operator, context)
+
+        case condition.child_relation
+        when :or
+          break if Liquid::Utils.to_liquid_value(result)
+        when :and
+          break unless Liquid::Utils.to_liquid_value(result)
+        else
+          break
+        end
+        condition = condition.child_condition
+      end
+      result
+    end
+
+    def or(condition)
+      @child_relation  = :or
+      @child_condition = condition
+    end
+
+    def and(condition)
+      @child_relation  = :and
+      @child_condition = condition
     end
 
     def attach(attachment)
@@ -38,6 +111,91 @@ module Liquid
 
     private
 
+    def equal_variables(left, right)
+      if left.is_a?(MethodLiteral)
+        return call_method_literal(left, right)
+      end
+
+      if right.is_a?(MethodLiteral)
+        return call_method_literal(right, left)
+      end
+
+      left == right
+    end
+
+    def call_method_literal(literal, value)
+      method_name = literal.method_name
+
+      # If the object responds to the method (e.g., ActiveSupport is loaded), use it
+      if value.respond_to?(method_name)
+        value.send(method_name)
+      else
+        # Emulate ActiveSupport's blank?/empty? to make Liquid invariant
+        # to whether ActiveSupport is loaded or not
+        case method_name
+        when :blank?
+          liquid_blank?(value)
+        when :empty?
+          liquid_empty?(value)
+        else
+          false
+        end
+      end
+    end
+
+    # Implement blank? semantics matching ActiveSupport
+    # blank? returns true for nil, false, empty strings, whitespace-only strings,
+    # empty arrays, and empty hashes
+    def liquid_blank?(value)
+      case value
+      when NilClass, FalseClass
+        true
+      when TrueClass, Numeric
+        false
+      when String
+        # Blank if empty or whitespace only (matches ActiveSupport)
+        value.empty? || value.match?(/\A\s*\z/)
+      when Array, Hash
+        value.empty?
+      else
+        # Fall back to empty? if available, otherwise false
+        value.respond_to?(:empty?) ? value.empty? : false
+      end
+    end
+
+    # Implement empty? semantics
+    # Note: nil is NOT empty. empty? checks if a collection has zero elements.
+    def liquid_empty?(value)
+      case value
+      when String, Array, Hash
+        value.empty?
+      else
+        value.respond_to?(:empty?) ? value.empty? : false
+      end
+    end
+
+    def interpret_condition(left, right, op, context)
+      # If the operator is empty this means that the decision statement is just
+      # a single variable. We can just poll this variable from the context and
+      # return this as the result.
+      return context.evaluate(left) if op.nil?
+
+      left  = Liquid::Utils.to_liquid_value(context.evaluate(left))
+      right = Liquid::Utils.to_liquid_value(context.evaluate(right))
+
+      operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
+
+      if operation.respond_to?(:call)
+        operation.call(self, left, right)
+      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
+        begin
+          left.send(operation, right)
+        rescue ::ArgumentError => e
+          raise Liquid::ArgumentError, e.message
+        end
+      end
+    end
+
     def deprecated_default_context
       warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated " \
         "and will be removed from Liquid 6.0.0.")
@@ -48,6 +206,8 @@ module Liquid
       def children
         [
           @node.left,
+          @node.right,
+          @node.child_condition,
           @node.attachment
         ].compact
       end

lib/liquid/context.rb

@@ -60,6 +60,10 @@ module Liquid
     end
     # rubocop:enable Metrics/ParameterLists
 
+    def warnings
+      @warnings ||= []
+    end
+
     def strainer
       @strainer ||= @environment.create_strainer(self, @filters)
     end
@@ -153,6 +157,7 @@ module Liquid
         subcontext.filters  = @filters
         subcontext.strainer = nil
         subcontext.errors   = errors
+        subcontext.warnings = warnings
         subcontext.disabled_tags = @disabled_tags
       end
     end
@@ -175,8 +180,7 @@ module Liquid
     # Example:
     #   products == empty #=> products.empty?
     def [](expression)
-      @string_scanner.string = expression
-      evaluate(Parser.new(@string_scanner).expression)
+      evaluate(Expression.parse(expression, @string_scanner))
     end
 
     def key?(key)
@@ -240,7 +244,7 @@ module Liquid
 
     protected
 
-    attr_writer :base_scope_depth, :errors, :strainer, :filters, :disabled_tags
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
 
     private
 

lib/liquid/environment.rb

@@ -4,6 +4,10 @@ module Liquid
   # The Environment is the container for all configuration options of Liquid, such as
   # the registered tags, filters, and the default error mode.
   class Environment
+    # The default error mode for all templates. This can be overridden on a
+    # per-template basis.
+    attr_accessor :error_mode
+
     # The tags that are available to use in the template.
     attr_accessor :tags
 
@@ -29,14 +33,17 @@ module Liquid
       #  the template.
       # @param file_system The default file system that is used
       #  to load templates from.
+      # @param error_mode [Symbol] The default error mode for all templates
+      #  (either :strict2, :strict, :warn, or :lax).
       # @param exception_renderer [Proc] The exception renderer that is used to
       #   render exceptions.
       # @yieldparam environment [Environment] The environment instance that is being built.
       # @return [Environment] The new environment instance.
-      def build(tags: nil, file_system: nil, exception_renderer: nil)
+      def build(tags: nil, file_system: nil, error_mode: nil, exception_renderer: nil)
         ret = new
         ret.tags = tags if tags
         ret.file_system = file_system if file_system
+        ret.error_mode = error_mode if error_mode
         ret.exception_renderer = exception_renderer if exception_renderer
         yield ret if block_given?
         ret.freeze
@@ -68,6 +75,7 @@ module Liquid
     # @api private
     def initialize
       @tags = Tags::STANDARD_TAGS.dup
+      @error_mode = :lax
       @strainer_template = Class.new(StrainerTemplate).tap do |klass|
         klass.add_filter(StandardFilters)
       end

lib/liquid/expression.rb

@@ -9,8 +9,11 @@ module Liquid
       '' => nil,
       'true' => true,
       'false' => false,
-      'blank' => MethodLiteral::BLANK,
-      'empty' => MethodLiteral::EMPTY,
+      'blank' => '',
+      'empty' => '',
+      # in lax mode, minus sign can be a VariableLookup
+      # For simplicity and performace, we treat it like a literal
+      '-' => VariableLookup.parse("-", nil).freeze,
     }.freeze
 
     DOT = ".".ord
@@ -25,6 +28,10 @@ module Liquid
     FLOAT_REGEX = /\A(-?\d+)\.\d+\z/
 
     class << self
+      def safe_parse(parser, ss = StringScanner.new(""), cache = nil)
+        parse(parser.expression, ss, cache)
+      end
+
       def parse(markup, ss = StringScanner.new(""), cache = nil)
         return unless markup
 
@@ -49,34 +56,71 @@ module Liquid
 
       def inner_parse(markup, ss, cache)
         if markup.start_with?("(") && markup.end_with?(")") && markup =~ RANGES_REGEX
-          start_markup = Regexp.last_match(1)
-          end_markup = Regexp.last_match(2)
-          start_obj = parse(start_markup, ss, cache)
-          end_obj = parse(end_markup, ss, cache)
-          return RangeLookup.create(
-            start_obj,
-            end_obj,
-            start_markup,
-            end_markup,
+          return RangeLookup.parse(
+            Regexp.last_match(1),
+            Regexp.last_match(2),
+            ss,
+            cache,
           )
         end
 
-        if (num = parse_number(markup))
+        if (num = parse_number(markup, ss))
           num
         else
           VariableLookup.parse(markup, ss, cache)
         end
       end
 
-      def parse_number(markup)
+      def parse_number(markup, ss)
         # check if the markup is simple integer or float
         case markup
         when INTEGER_REGEX
-          Integer(markup, 10)
+          return Integer(markup, 10)
         when FLOAT_REGEX
-          markup.to_f
+          return markup.to_f
+        end
+
+        ss.string = markup
+        # the first byte must be a digit or  a dash
+        byte = ss.scan_byte
+
+        return false if byte != DASH && (byte < ZERO || byte > NINE)
+
+        if byte == DASH
+          peek_byte = ss.peek_byte
+
+          # if it starts with a dash, the next byte must be a digit
+          return false if peek_byte.nil? || !(peek_byte >= ZERO && peek_byte <= NINE)
+        end
+
+        # The markup could be a float with multiple dots
+        first_dot_pos = nil
+        num_end_pos = nil
+
+        while (byte = ss.scan_byte)
+          return false if byte != DOT && (byte < ZERO || byte > NINE)
+
+          # we found our number and now we are just scanning the rest of the string
+          next if num_end_pos
+
+          if byte == DOT
+            if first_dot_pos.nil?
+              first_dot_pos = ss.pos
+            else
+              # we found another dot, so we know that the number ends here
+              num_end_pos = ss.pos - 1
+            end
+          end
+        end
+
+        num_end_pos = markup.length if ss.eos?
+
+        if num_end_pos
+          # number ends with a number "123.123"
+          markup.byteslice(0, num_end_pos).to_f
         else
-          false
+          # number ends with a dot "123."
+          markup.byteslice(0, first_dot_pos).to_f
         end
       end
     end

lib/liquid/lexer.rb

@@ -6,24 +6,22 @@ module Liquid
     CLOSE_SQUARE = [:close_square, "]"].freeze
     COLON = [:colon, ":"].freeze
     COMMA = [:comma, ","].freeze
+    COMPARISION_NOT_EQUAL = [:comparison, "!="].freeze
     COMPARISON_CONTAINS = [:comparison, "contains"].freeze
+    COMPARISON_EQUAL = [:comparison, "=="].freeze
     COMPARISON_GREATER_THAN = [:comparison, ">"].freeze
     COMPARISON_GREATER_THAN_OR_EQUAL = [:comparison, ">="].freeze
     COMPARISON_LESS_THAN = [:comparison, "<"].freeze
     COMPARISON_LESS_THAN_OR_EQUAL = [:comparison, "<="].freeze
-    EQUALITY_EQUAL_EQUAL = [:equality, "=="].freeze
-    EQUALITY_NOT_EQUAL = [:equality, "!="].freeze
-    EQUALITY_NOT_EQUAL_ALT = [:equality, "<>"].freeze
+    COMPARISON_NOT_EQUAL_ALT = [:comparison, "<>"].freeze
     DASH = [:dash, "-"].freeze
     DOT = [:dot, "."].freeze
     DOTDOT = [:dotdot, ".."].freeze
     DOT_ORD = ".".ord
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
     EOS = [:end_of_string].freeze
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
-    LOGICAL_AND = [:logical, 'and'].freeze
-    LOGICAL_OR = [:logical, 'or'].freeze
-    NUMBER_LITERAL = /-?\d+(\.\d+)?/
+    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
+    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
     OPEN_ROUND = [:open_round, "("].freeze
     OPEN_SQUARE = [:open_square, "["].freeze
     PIPE = [:pipe, "|"].freeze
@@ -40,11 +38,11 @@ module Liquid
 
     TWO_CHARS_COMPARISON_JUMP_TABLE = [].tap do |table|
       table["=".ord] = [].tap do |sub_table|
-        sub_table["=".ord] = EQUALITY_EQUAL_EQUAL
+        sub_table["=".ord] = COMPARISON_EQUAL
         sub_table.freeze
       end
       table["!".ord] = [].tap do |sub_table|
-        sub_table["=".ord] = EQUALITY_NOT_EQUAL
+        sub_table["=".ord] = COMPARISION_NOT_EQUAL
         sub_table.freeze
       end
       table.freeze
@@ -53,7 +51,7 @@ module Liquid
     COMPARISON_JUMP_TABLE = [].tap do |table|
       table["<".ord] = [].tap do |sub_table|
         sub_table["=".ord] = COMPARISON_LESS_THAN_OR_EQUAL
-        sub_table[">".ord] = EQUALITY_NOT_EQUAL_ALT
+        sub_table[">".ord] = COMPARISON_NOT_EQUAL_ALT
         sub_table.freeze
       end
       table[">".ord] = [].tap do |sub_table|
@@ -153,10 +151,6 @@ module Liquid
               # Special case for "contains"
               output << if type == :id && t == "contains" && output.last&.first != :dot
                 COMPARISON_CONTAINS
-              elsif type == :id && t == "and" && output.last&.first != :dot
-                LOGICAL_AND
-              elsif type == :id && t == "or" && output.last&.first != :dot
-                LOGICAL_OR
               else
                 [type, t]
               end

lib/liquid/method_literal.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class MethodLiteral
-    attr_reader :method_name, :to_s
-
-    def initialize(method_name, to_s, &evaluator)
-      @method_name = method_name
-      @to_s = to_s
-      @evaluator = evaluator
-    end
-
-    def apply(value)
-      if value.respond_to?(@method_name)
-        value.send(@method_name)
-      elsif @evaluator
-        @evaluator.call(value)
-      end
-    end
-
-    def to_liquid
-      to_s
-    end
-
-    BLANK = MethodLiteral.new(:blank?, '') do |value|
-      case value
-      when NilClass, FalseClass
-        true
-      when TrueClass, Numeric
-        false
-      when String
-        value.empty? || value.match?(/\A\s*\z/)
-      when Array, Hash
-        value.empty?
-      else
-        value.respond_to?(:empty?) ? value.empty? : false
-      end
-    end.freeze
-
-    EMPTY = MethodLiteral.new(:empty?, '') do |value|
-      case value
-      when String, Array, Hash
-        value.empty?
-      else
-        value.respond_to?(:empty?) ? value.empty? : nil
-      end
-    end.freeze
-  end
-end

lib/liquid/parse_context.rb

@@ -3,13 +3,14 @@
 module Liquid
   class ParseContext
     attr_accessor :locale, :line_number, :trim_whitespace, :depth
-    attr_reader :partial, :environment
+    attr_reader :partial, :warnings, :error_mode, :environment
 
     def initialize(options = Const::EMPTY_HASH)
       @environment = options.fetch(:environment, Environment.default)
       @template_options = options ? options.dup : {}
 
-      @locale = @template_options[:locale] ||= I18n.new
+      @locale   = @template_options[:locale] ||= I18n.new
+      @warnings = []
 
       # constructing new StringScanner in Lexer, Tokenizer, etc is expensive
       # This StringScanner will be shared by all of them
@@ -37,7 +38,7 @@ module Liquid
 
     def new_parser(input)
       @string_scanner.string = input
-      Parser.new(@string_scanner, @expression_cache)
+      Parser.new(@string_scanner)
     end
 
     def new_tokenizer(source, start_line_number: nil, for_liquid_tag: false)
@@ -49,9 +50,30 @@ module Liquid
       )
     end
 
+    def safe_parse_expression(parser)
+      Expression.safe_parse(parser, @string_scanner, @expression_cache)
+    end
+
+    def parse_expression(markup, safe: false)
+      if !safe && @error_mode == :strict2
+        # parse_expression is a widely used API. To maintain backward
+        # compatibility while raising awareness about strict2 parser standards,
+        # the safe flag supports API users make a deliberate decision.
+        #
+        # In strict2 mode, markup MUST come from a string returned by the parser
+        # (e.g., parser.expression). We're not calling the parser here to
+        # prevent redundant parser overhead.
+        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
+      end
+
+      Expression.parse(markup, @string_scanner, @expression_cache)
+    end
+
     def partial=(value)
       @partial = value
       @options = value ? partial_options : @template_options
+
+      @error_mode = @options[:error_mode] || @environment.error_mode
     end
 
     def partial_options

lib/liquid/parser.rb

@@ -2,10 +2,9 @@
 
 module Liquid
   class Parser
-    def initialize(input, expression_cache = nil)
-      @ss = input.is_a?(StringScanner) ? input : StringScanner.new(input)
-      @cache = expression_cache
-      @tokens = Lexer.tokenize(@ss)
+    def initialize(input)
+      ss = input.is_a?(StringScanner) ? input : StringScanner.new(input)
+      @tokens = Lexer.tokenize(ss)
       @p      = 0 # pointer to current location
     end
 
@@ -13,8 +12,6 @@ module Liquid
       @p = point
     end
 
-    # Consumes a token of specific type.
-    # Throws SyntaxError if token doesn't match type expectation.
     def consume(type = nil)
       token = @tokens[@p]
       if type && token[0] != type
@@ -43,154 +40,30 @@ module Liquid
       token[1]
     end
 
-    # Peeks the ahead token, returning true if matching expectation
     def look(type, ahead = 0)
       tok = @tokens[@p + ahead]
       return false unless tok
       tok[0] == type
     end
 
-    # expression := logical
-    # logical    := equality (("and" | "or") equality)*
-    # equality   := comparison (("==" | "!=" | "<>") comparison)*
-    # comparison := primary ((">=" | ">" | "<" | "<=" | ... ) primary)*
-    # primary    := string | number | variable_lookup | range | boolean | grouping
     def expression
-      logical
-    end
-
-    # Logical relations use right-to-left associativity.
-    # `a and b or c` is evaluated like (a and (b or c))
-    # This enables short-circuit: if `a` is false, entire expression short-circuits.
-    # logical := equality (("and" | "or") logical)?
-    def logical
-      left = equality
-      if (operator = consume?(:logical))
-        right = logical # recursive call builds proper RTL tree
-        BinaryExpression.new(left, operator, right)
-      else
-        left
-      end
-    end
-
-    # equality := comparison (("==" | "!=" | "<>") comparison)*
-    def equality
-      expr = comparison
-      while look(:equality)
-        operator = consume
-        expr = BinaryExpression.new(expr, operator, comparison)
-      end
-      expr
-    end
-
-    # comparison := primary ((">=" | ">" | "<" | "<=" | ... ) primary)*
-    def comparison
-      expr = primary
-      while look(:comparison)
-        operator = consume
-        expr = BinaryExpression.new(expr, operator, primary)
-      end
-      expr
-    end
-
-    # primary := string | number | variable_lookup | range | boolean | grouping
-    def primary
-      token = @tokens[@p]
-      case token[0]
-      when :id
-        variable_lookup_or_literal
-      when :open_square
-        unnamed_variable_lookup
-      when :string
-        string
-      when :number
-        number
-      when :open_round
-        grouping_or_range_lookup
-      else
-        raise SyntaxError, "#{token} is not a valid expression"
-      end
-    end
-
-    def number
-      num = consume(:number)
-      Expression.parse_number(num)
-    end
-
-    def string
-      consume(:string)[1..-2]
-    end
-
-    # variable_lookup := id (lookup)*
-    # lookup          := indexed_lookup | dot_lookup
-    # indexed_lookup  := "[" expression "]"
-    # dot_lookup      := "." id
-    def variable_lookup
-      name = consume(:id)
-      lookups, command_flags = variable_lookups
-      VariableLookup.new(name, lookups, command_flags)
-    end
-
-    # a variable_lookup without lookups could be a literal
-    def variable_lookup_or_literal
-      name = consume(:id)
-      lookups, command_flags = variable_lookups
-      if Expression::LITERALS.key?(name) && lookups.empty?
-        Expression::LITERALS[name]
-      else
-        VariableLookup.new(name, lookups, command_flags)
-      end
-    end
-
-    # unnamed_variable_lookup := indexed_lookup (lookup)*
-    def unnamed_variable_lookup
-      name = indexed_lookup
-      lookups, command_flags = variable_lookups
-      VariableLookup.new(name, lookups, command_flags)
-    end
-
-    # Parenthesized expressions are recursive
-    # grouping     := "(" expression ")"
-    def grouping_or_range_lookup
-      consume(:open_round)
-      expr = expression
-      if consume?(:dotdot)
-        RangeLookup.create(expr, expression)
-      else
-        expr
-      end
-    ensure
-      consume(:close_round)
-    end
-
-    # range_lookup := "(" expression ".." expression ")"
-    def range_lookup
-      consume(:open_round)
-      first = expression
-      consume(:dotdot)
-      last = expression
-      consume(:close_round)
-      RangeLookup.create(first, last)
-    end
-
-    def expression_string
       token = @tokens[@p]
       case token[0]
       when :id
         str = consume
-        str << variable_lookups_string
+        str << variable_lookups
       when :open_square
         str = consume.dup
-        str << expression_string
+        str << expression
         str << consume(:close_square)
-        str << variable_lookups_string
+        str << variable_lookups
       when :string, :number
         consume
       when :open_round
         consume
-        first = expression_string
+        first = expression
         consume(:dotdot)
-        last = expression_string
+        last = expression
         consume(:close_round)
         "(#{first}..#{last})"
       else
@@ -198,23 +71,23 @@ module Liquid
       end
     end
 
-    def argument_string
+    def argument
       str = +""
       # might be a keyword argument (identifier: expression)
       if look(:id) && look(:colon, 1)
         str << consume << consume << ' '
       end
 
-      str << expression_string
+      str << expression
       str
     end
 
-    def variable_lookups_string
+    def variable_lookups
       str = +""
       loop do
         if look(:open_square)
           str << consume
-          str << expression_string
+          str << expression
           str << consume(:close_square)
         elsif look(:dot)
           str << consume
@@ -225,43 +98,5 @@ module Liquid
       end
       str
     end
-
-    # Assumes safe input. For cases where you need the string.
-    # Don't use this unless you're sure about what you're doing.
-    def unsafe_parse_expression(markup)
-      parse_expression(markup)
-    end
-
-    private
-
-    def parse_expression(markup)
-      Expression.parse(markup, @ss, @cache)
-    end
-
-    def variable_lookups
-      lookups = []
-      command_flags = 0
-      i = -1
-      loop do
-        i += 1
-        if look(:open_square)
-          lookups << indexed_lookup
-        elsif consume?(:dot)
-          lookup = consume(:id)
-          lookups << lookup
-          command_flags |= 1 << i if VariableLookup::COMMAND_METHODS.include?(lookup)
-        else
-          break
-        end
-      end
-      [lookups, command_flags]
-    end
-
-    def indexed_lookup
-      consume(:open_square)
-      expr = expression
-      consume(:close_square)
-      expr
-    end
   end
 end

lib/liquid/parser_switching.rb

@@ -2,15 +2,74 @@
 
 module Liquid
   module ParserSwitching
+    # Do not use this.
+    #
+    # It's basically doing the same thing the {#parse_with_selected_parser},
+    # except this will try the strict parser regardless of the error mode,
+    # and fall back to the lax parser if the error mode is lax or warn,
+    # except when in strict2 mode where it uses the strict2 parser.
+    #
+    # @deprecated Use {#parse_with_selected_parser} instead.
+    def strict_parse_with_error_mode_fallback(markup)
+      return strict2_parse_with_error_context(markup) if strict2_mode?
+
+      strict_parse_with_error_context(markup)
+    rescue SyntaxError => e
+      case parse_context.error_mode
+      when :rigid
+        rigid_warn
+        raise
+      when :strict2
+        raise
+      when :strict
+        raise
+      when :warn
+        parse_context.warnings << e
+      end
+      lax_parse(markup)
+    end
+
     def parse_with_selected_parser(markup)
-      parse_markup(markup)
+      case parse_context.error_mode
+      when :rigid   then rigid_warn && strict2_parse_with_error_context(markup)
+      when :strict2 then strict2_parse_with_error_context(markup)
+      when :strict  then strict_parse_with_error_context(markup)
+      when :lax     then lax_parse(markup)
+      when :warn
+        begin
+          strict2_parse_with_error_context(markup)
+        rescue SyntaxError => e
+          parse_context.warnings << e
+          lax_parse(markup)
+        end
+      end
+    end
+
+    def strict2_mode?
+      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
+    end
+
+    private
+
+    def rigid_warn
+      Deprecations.warn(':rigid', ':strict2')
+    end
+
+    def strict2_parse_with_error_context(markup)
+      strict2_parse(markup)
     rescue SyntaxError => e
       e.line_number    = line_number
       e.markup_context = markup_context(markup)
       raise e
     end
 
-    private
+    def strict_parse_with_error_context(markup)
+      strict_parse(markup)
+    rescue SyntaxError => e
+      e.line_number    = line_number
+      e.markup_context = markup_context(markup)
+      raise e
+    end
 
     def markup_context(markup)
       "in \"#{markup.strip}\""

lib/liquid/partial_cache.rb

@@ -4,7 +4,7 @@ module Liquid
   class PartialCache
     def self.load(template_name, context:, parse_context:)
       cached_partials = context.registers[:cached_partials]
-      cache_key = template_name.to_s
+      cache_key = "#{template_name}:#{parse_context.error_mode}"
       cached = cached_partials[cache_key]
       return cached if cached
 

lib/liquid/range_lookup.rb

@@ -2,15 +2,15 @@
 
 module Liquid
   class RangeLookup
-    def self.create(start_obj, end_obj, start_markup = nil, end_markup = nil)
+    def self.parse(start_markup, end_markup, string_scanner, cache = nil)
+      start_obj = Expression.parse(start_markup, string_scanner, cache)
+      end_obj   = Expression.parse(end_markup, string_scanner, cache)
       if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
         new(start_obj, end_obj)
       else
         begin
           start_obj.to_i..end_obj.to_i
         rescue NoMethodError
-          start_markup = start_obj.to_s unless start_markup
-          end_markup = end_obj.to_s unless end_markup
           invalid_expr = start_markup unless start_obj.respond_to?(:to_i)
           invalid_expr ||= end_markup unless end_obj.respond_to?(:to_i)
           if invalid_expr

lib/liquid/resource_limits.rb

@@ -2,24 +2,39 @@
 
 module Liquid
   class ResourceLimits
-    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
-    attr_reader :render_score, :assign_score
+    attr_accessor :render_length_limit,
+      :render_score_limit,
+      :assign_score_limit,
+      :cumulative_render_score_limit,
+      :cumulative_assign_score_limit
+    attr_reader :render_score,
+      :assign_score,
+      :cumulative_render_score,
+      :cumulative_assign_score
 
     def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit  = limits[:render_score_limit]
-      @assign_score_limit  = limits[:assign_score_limit]
+      @render_length_limit           = limits[:render_length_limit]
+      @render_score_limit            = limits[:render_score_limit]
+      @assign_score_limit            = limits[:assign_score_limit]
+      @cumulative_render_score_limit = limits[:cumulative_render_score_limit]
+      @cumulative_assign_score_limit = limits[:cumulative_assign_score_limit]
+      @cumulative_render_score = 0
+      @cumulative_assign_score = 0
       reset
     end
 
     def increment_render_score(amount)
       @render_score += amount
+      @cumulative_render_score += amount
       raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
+      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
     end
 
     def increment_assign_score(amount)
       @assign_score += amount
+      @cumulative_assign_score += amount
       raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
+      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
     end
 
     # update either render_length or assign_score based on whether or not the writes are captured
@@ -47,6 +62,8 @@ module Liquid
       @reached_limit = false
       @last_capture_length = nil
       @render_score = @assign_score = 0
+      raise_limits_reached if @cumulative_render_score_limit && @cumulative_render_score > @cumulative_render_score_limit
+      raise_limits_reached if @cumulative_assign_score_limit && @cumulative_assign_score > @cumulative_assign_score_limit
     end
 
     def with_capture

lib/liquid/standardfilters.rb

@@ -293,6 +293,19 @@ module Liquid
       input.split(pattern)
     end
 
+    # @liquid_public_docs
+    # @liquid_type filter
+    # @liquid_category string
+    # @liquid_summary
+    #   Removes leading and trailing whitespace and collapses consecutive whitespace to a single space.
+    # @liquid_syntax string | squish
+    # @liquid_return [string]
+    def squish(input)
+      return if input.nil?
+
+      Utils.to_s(input).strip.gsub(/\s+/, ' ')
+    end
+
     # @liquid_public_docs
     # @liquid_type filter
     # @liquid_category string

lib/liquid/tag.rb

@@ -65,5 +65,15 @@ module Liquid
     def blank?
       false
     end
+
+    private
+
+    def safe_parse_expression(parser)
+      parse_context.safe_parse_expression(parser)
+    end
+
+    def parse_expression(markup, safe: false)
+      parse_context.parse_expression(markup, safe: safe)
+    end
   end
 end

lib/liquid/tags/case.rb

@@ -23,6 +23,9 @@ module Liquid
   # @liquid_syntax_keyword second_expression An expression to be rendered when the variable's value matches `second_value`.
   # @liquid_syntax_keyword third_expression An expression to be rendered when the variable's value has no match.
   class Case < Block
+    Syntax     = /(#{QuotedFragment})/o
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
+
     attr_reader :blocks, :left
 
     def initialize(tag_name, markup, options)
@@ -83,33 +86,63 @@ module Liquid
 
     private
 
-    def parse_markup(markup)
+    def strict2_parse(markup)
       parser = @parse_context.new_parser(markup)
-      @left = parser.expression
+      @left = safe_parse_expression(parser)
       parser.consume(:end_of_string)
     end
 
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @left = parse_expression(Regexp.last_match(1))
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.case")
+      end
+    end
+
     def record_when_condition(markup)
       body = new_body
 
-      parse_when(markup, body)
+      if strict2_mode?
+        parse_strict2_when(markup, body)
+      else
+        parse_lax_when(markup, body)
+      end
     end
 
-    def parse_when(markup, body)
+    def parse_strict2_when(markup, body)
       parser = @parse_context.new_parser(markup)
 
       loop do
-        expr = BinaryExpression.new(@left, '==', parser.equality)
-        block = Condition.new(expr)
+        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
+        block = Condition.new(@left, '==', expr)
         block.attach(body)
         @blocks << block
 
-        break unless parser.consume?(:logical) == 'or' || parser.consume?(:comma)
+        break unless parser.id?('or') || parser.consume?(:comma)
       end
 
       parser.consume(:end_of_string)
     end
 
+    def parse_lax_when(markup, body)
+      while markup
+        unless markup =~ WhenSyntax
+          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
+        end
+
+        markup = Regexp.last_match(2)
+
+        block = Condition.new(@left, '==', Condition.parse_expression(parse_context, Regexp.last_match(1)))
+        block.attach(body)
+        @blocks << block
+      end
+    end
+
     def record_else_condition(markup)
       unless markup.strip.empty?
         raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else")

lib/liquid/tags/cycle.rb

@@ -15,6 +15,8 @@ module Liquid
   # @liquid_syntax
   #   {% cycle string, string, ... %}
   class Cycle < Tag
+    SimpleSyntax = /\A#{QuotedFragment}+/o
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
     UNNAMED_CYCLE_PATTERN = /\w+:0x\h{8}/
 
     attr_reader :variables
@@ -54,21 +56,21 @@ module Liquid
     private
 
     # cycle [name:] expression(, expression)*
-    def parse_markup(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @variables = []
 
       raise SyntaxError, options[:locale].t("errors.syntax.cycle") if p.look(:end_of_string)
 
-      first_expression = p.expression
+      first_expression = safe_parse_expression(p)
       if p.look(:colon)
         # cycle name: expr1, expr2, ...
         @name = first_expression
         @is_named = true
         p.consume(:colon)
         # After the colon, parse the first variable (required for named cycles)
-        @variables << maybe_dup_lookup(p.expression)
+        @variables << maybe_dup_lookup(safe_parse_expression(p))
       else
         # cycle expr1, expr2, ...
         @variables << maybe_dup_lookup(first_expression)
@@ -78,7 +80,7 @@ module Liquid
       while p.consume?(:comma)
         break if p.look(:end_of_string)
 
-        @variables << maybe_dup_lookup(p.expression)
+        @variables << maybe_dup_lookup(safe_parse_expression(p))
       end
 
       p.consume(:end_of_string)
@@ -89,6 +91,35 @@ module Liquid
       end
     end
 
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      case markup
+      when NamedSyntax
+        @variables = variables_from_string(Regexp.last_match(2))
+        @name      = parse_expression(Regexp.last_match(1))
+        @is_named = true
+      when SimpleSyntax
+        @variables = variables_from_string(markup)
+        @name      = @variables.to_s
+        @is_named = !@name.match?(UNNAMED_CYCLE_PATTERN)
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+      end
+    end
+
+    def variables_from_string(markup)
+      markup.split(',').collect do |var|
+        var =~ /\s*(#{QuotedFragment})\s*/o
+        next unless Regexp.last_match(1)
+
+        var = parse_expression(Regexp.last_match(1))
+        maybe_dup_lookup(var)
+      end.compact
+    end
+
     # For backwards compatibility, whenever a lookup is used in an unnamed cycle,
     # we make it so that the @variables.to_s produces different strings for cycles
     # called with the same arguments (since @variables.to_s is used as the cycle counter key)

lib/liquid/tags/for.rb

@@ -25,6 +25,8 @@ module Liquid
   # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   # @liquid_optional_param reversed [untyped] Iterate in reverse order.
   class For < Block
+    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
+
     attr_reader :collection_name, :variable_name, :limit, :from
 
     def initialize(tag_name, markup, options)
@@ -70,13 +72,28 @@ module Liquid
 
     protected
 
-    def parse_markup(markup)
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @variable_name   = Regexp.last_match(1)
+        collection_name  = Regexp.last_match(2)
+        @reversed        = !!Regexp.last_match(3)
+        @name            = "#{@variable_name}-#{collection_name}"
+        @collection_name = parse_expression(collection_name)
+        markup.scan(TagAttributes) do |key, value|
+          set_attribute(key, value)
+        end
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.for")
+      end
+    end
+
+    def strict_parse(markup)
       p = @parse_context.new_parser(markup)
       @variable_name = p.consume(:id)
       raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
 
-      collection_name  = p.expression_string
-      @collection_name = p.unsafe_parse_expression(collection_name)
+      collection_name  = p.expression
+      @collection_name = parse_expression(collection_name, safe: true)
 
       @name     = "#{@variable_name}-#{collection_name}"
       @reversed = p.id?('reversed')
@@ -87,13 +104,17 @@ module Liquid
           raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
         end
         p.consume(:colon)
-        set_attribute(attribute, p)
+        set_attribute(attribute, p.expression, safe: true)
       end
       p.consume(:end_of_string)
     end
 
     private
 
+    def strict2_parse(markup)
+      strict_parse(markup)
+    end
+
     def collection_segment(context)
       offsets = context.registers[:for] ||= {}
 
@@ -157,17 +178,16 @@ module Liquid
       output
     end
 
-    def set_attribute(key, p)
-      expr = p.expression_string
+    def set_attribute(key, expr, safe: false)
       case key
       when 'offset'
         @from = if expr == 'continue'
           :continue
         else
-          p.unsafe_parse_expression(expr)
+          parse_expression(expr, safe: safe)
         end
       when 'limit'
-        @limit = p.unsafe_parse_expression(expr)
+        @limit = parse_expression(expr, safe: safe)
       end
     end
 

lib/liquid/tags/if.rb

@@ -14,6 +14,10 @@ module Liquid
   # @liquid_syntax_keyword condition The condition to evaluate.
   # @liquid_syntax_keyword expression The expression to render if the condition is met.
   class If < Block
+    Syntax                  = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
+    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
+    BOOLEAN_OPERATORS       = %w(and or).freeze
+
     attr_reader :blocks
 
     def initialize(tag_name, markup, options)
@@ -62,6 +66,10 @@ module Liquid
 
     private
 
+    def strict2_parse(markup)
+      strict_parse(markup)
+    end
+
     def push_block(tag, markup)
       block = if tag == 'else'
         ElseCondition.new
@@ -73,13 +81,58 @@ module Liquid
       block.attach(new_body)
     end
 
-    def parse_markup(markup)
+    def parse_expression(markup, safe: false)
+      Condition.parse_expression(parse_context, markup, safe: safe)
+    end
+
+    def lax_parse(markup)
+      expressions = markup.scan(ExpressionsAndOperators)
+      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
+
+      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+
+      until expressions.empty?
+        operator = expressions.pop.to_s.strip
+
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+
+        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
+        new_condition.send(operator, condition)
+        condition = new_condition
+      end
+
+      condition
+    end
+
+    def strict_parse(markup)
       p = @parse_context.new_parser(markup)
-      condition = Condition.new(p.expression)
+      condition = parse_binary_comparisons(p)
       p.consume(:end_of_string)
       condition
     end
 
+    def parse_binary_comparisons(p)
+      condition = parse_comparison(p)
+      first_condition = condition
+      while (op = p.id?('and') || p.id?('or'))
+        child_condition = parse_comparison(p)
+        condition.send(op, child_condition)
+        condition = child_condition
+      end
+      first_condition
+    end
+
+    def parse_comparison(p)
+      a = parse_expression(p.expression, safe: true)
+      if (op = p.consume?(:comparison))
+        b = parse_expression(p.expression, safe: true)
+        Condition.new(a, op, b)
+      else
+        Condition.new(a)
+      end
+    end
+
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         @node.blocks

lib/liquid/tags/include.rb

@@ -20,6 +20,9 @@ module Liquid
   class Include < Tag
     prepend Tag::Disableable
 
+    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    Syntax = SYNTAX
+
     attr_reader :template_name_expr, :variable_name_expr, :attributes
 
     def initialize(tag_name, markup, options)
@@ -81,11 +84,11 @@ module Liquid
     alias_method :parse_context, :options
     private :parse_context
 
-    def parse_markup(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
-      @template_name_expr = p.expression
-      @variable_name_expr = p.expression if p.id?("for") || p.id?("with")
+      @template_name_expr = safe_parse_expression(p)
+      @variable_name_expr = safe_parse_expression(p) if p.id?("for") || p.id?("with")
       @alias_name         = p.consume(:id) if p.id?("as")
 
       p.consume?(:comma)
@@ -94,13 +97,36 @@ module Liquid
       while p.look(:id)
         key = p.consume
         p.consume(:colon)
-        @attributes[key] = p.expression
+        @attributes[key] = safe_parse_expression(p)
         p.consume?(:comma)
       end
 
       p.consume(:end_of_string)
     end
 
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      if markup =~ SYNTAX
+        template_name = Regexp.last_match(1)
+        variable_name = Regexp.last_match(3)
+
+        @alias_name         = Regexp.last_match(5)
+        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+        @template_name_expr = parse_expression(template_name)
+        @attributes         = {}
+
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = parse_expression(value)
+        end
+
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.include")
+      end
+    end
+
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [

lib/liquid/tags/render.rb

@@ -27,6 +27,7 @@ module Liquid
   # @liquid_syntax_keyword filename The name of the snippet to render, without the `.liquid` extension.
   class Render < Tag
     FOR = 'for'
+    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
 
     disable_tags "include"
 
@@ -84,12 +85,12 @@ module Liquid
     end
 
     # render (string) (with|for expression)? (as id)? (key: value)*
-    def parse_markup(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
-      @template_name_expr = template_name(p)
+      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
       with_or_for         = p.id?("for") || p.id?("with")
-      @variable_name_expr = p.expression if with_or_for
+      @variable_name_expr = safe_parse_expression(p) if with_or_for
       @alias_name         = p.consume(:id) if p.id?("as")
       @is_for_loop        = (with_or_for == FOR)
 
@@ -99,15 +100,37 @@ module Liquid
       while p.look(:id)
         key = p.consume
         p.consume(:colon)
-        @attributes[key] = p.expression
+        @attributes[key] = safe_parse_expression(p)
         p.consume?(:comma)
       end
 
       p.consume(:end_of_string)
     end
 
-    def template_name(p)
-      p.string
+    def strict2_template_name(p)
+      p.consume(:string)
+    end
+
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
+
+      template_name = Regexp.last_match(1)
+      with_or_for = Regexp.last_match(3)
+      variable_name = Regexp.last_match(4)
+
+      @alias_name = Regexp.last_match(6)
+      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+      @template_name_expr = parse_expression(template_name)
+      @is_for_loop = (with_or_for == FOR)
+
+      @attributes = {}
+      markup.scan(TagAttributes) do |key, value|
+        @attributes[key] = parse_expression(value)
+      end
     end
 
     class ParseTreeVisitor < Liquid::ParseTreeVisitor

lib/liquid/tags/table_row.rb

@@ -24,6 +24,7 @@ module Liquid
   # @liquid_optional_param offset: [number] The 1-based index to start iterating at.
   # @liquid_optional_param range [untyped] A custom numeric range to iterate over.
   class TableRow < Block
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
     ALLOWED_ATTRIBUTES = ['cols', 'limit', 'offset', 'range'].freeze
 
     attr_reader :variable_name, :collection_name, :attributes
@@ -33,7 +34,7 @@ module Liquid
       parse_with_selected_parser(markup)
     end
 
-    def parse_markup(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @variable_name = p.consume(:id)
@@ -42,7 +43,7 @@ module Liquid
         raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in")
       end
 
-      @collection_name = p.expression
+      @collection_name = safe_parse_expression(p)
 
       p.consume?(:comma)
 
@@ -54,13 +55,30 @@ module Liquid
         end
 
         p.consume(:colon)
-        @attributes[key] = p.expression
+        @attributes[key] = safe_parse_expression(p)
         p.consume?(:comma)
       end
 
       p.consume(:end_of_string)
     end
 
+    def strict_parse(markup)
+      lax_parse(markup)
+    end
+
+    def lax_parse(markup)
+      if markup =~ Syntax
+        @variable_name   = Regexp.last_match(1)
+        @collection_name = parse_expression(Regexp.last_match(2))
+        @attributes      = {}
+        markup.scan(TagAttributes) do |key, value|
+          @attributes[key] = parse_expression(value)
+        end
+      else
+        raise SyntaxError, options[:locale].t("errors.syntax.table_row")
+      end
+    end
+
     def render_to_output_buffer(context, output)
       (collection = context.evaluate(@collection_name)) || (return '')
 

lib/liquid/template.rb

@@ -16,11 +16,25 @@ module Liquid
   #
   class Template
     attr_accessor :root, :name
-    attr_reader :resource_limits
+    attr_reader :resource_limits, :warnings
 
     attr_reader :profiler
 
     class << self
+      # Sets how strict the parser should be.
+      # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
+      # :warn is the default and will give deprecation warnings when invalid syntax is used.
+      # :strict enforces correct syntax for most tags
+      # :strict2 enforces correct syntax for all tags
+      def error_mode=(mode)
+        Deprecations.warn("Template.error_mode=", "Environment#error_mode=")
+        Environment.default.error_mode = mode
+      end
+
+      def error_mode
+        Environment.default.error_mode
+      end
+
       def default_exception_renderer=(renderer)
         Deprecations.warn("Template.default_exception_renderer=", "Environment#exception_renderer=")
         Environment.default.exception_renderer = renderer
@@ -209,6 +223,7 @@ module Liquid
         ParseContext.new(opts)
       end
 
+      @warnings = parse_context.warnings
       parse_context
     end
 

lib/liquid/variable.rb

@@ -30,7 +30,7 @@ module Liquid
       @parse_context = parse_context
       @line_number   = parse_context.line_number
 
-      parse_with_selected_parser(markup)
+      strict_parse_with_error_mode_fallback(markup)
     end
 
     def raw
@@ -41,17 +41,58 @@ module Liquid
       "in \"{{#{markup}}}\""
     end
 
-    def parse_markup(markup)
+    def lax_parse(markup)
+      @filters = []
+      return unless markup =~ MarkupWithQuotedFragment
+
+      name_markup   = Regexp.last_match(1)
+      filter_markup = Regexp.last_match(2)
+      @name         = parse_context.parse_expression(name_markup)
+      if filter_markup =~ FilterMarkupRegex
+        filters = Regexp.last_match(1).scan(FilterParser)
+        filters.each do |f|
+          next unless f =~ /\w+/
+          filtername = Regexp.last_match(0)
+          filterargs = f.scan(FilterArgsRegex).flatten
+          @filters << lax_parse_filter_expressions(filtername, filterargs)
+        end
+      end
+    end
+
+    def strict_parse(markup)
       @filters = []
       p = @parse_context.new_parser(markup)
 
       return if p.look(:end_of_string)
 
-      @name = p.expression
-      @filters << parse_filter_expressions(p) while p.consume?(:pipe)
+      @name = parse_context.safe_parse_expression(p)
+      while p.consume?(:pipe)
+        filtername = p.consume(:id)
+        filterargs = p.consume?(:colon) ? parse_filterargs(p) : Const::EMPTY_ARRAY
+        @filters << lax_parse_filter_expressions(filtername, filterargs)
+      end
       p.consume(:end_of_string)
     end
 
+    def strict2_parse(markup)
+      @filters = []
+      p = @parse_context.new_parser(markup)
+
+      return if p.look(:end_of_string)
+
+      @name = parse_context.safe_parse_expression(p)
+      @filters << strict2_parse_filter_expressions(p) while p.consume?(:pipe)
+      p.consume(:end_of_string)
+    end
+
+    def parse_filterargs(p)
+      # first argument
+      filterargs = [p.argument]
+      # followed by comma separated others
+      filterargs << p.argument while p.consume?(:comma)
+      filterargs
+    end
+
     def render(context)
       obj = context.evaluate(@name)
 
@@ -92,6 +133,22 @@ module Liquid
 
     private
 
+    def lax_parse_filter_expressions(filter_name, unparsed_args)
+      filter_args  = []
+      keyword_args = nil
+      unparsed_args.each do |a|
+        if (matches = a.match(JustTagAttributes))
+          keyword_args           ||= {}
+          keyword_args[matches[1]] = parse_context.parse_expression(matches[2])
+        else
+          filter_args << parse_context.parse_expression(a)
+        end
+      end
+      result = [filter_name, filter_args]
+      result << keyword_args if keyword_args
+      result
+    end
+
     # Surprisingly, positional and keyword arguments can be mixed.
     #
     # filter = filtername [":" filterargs?]
@@ -99,7 +156,7 @@ module Liquid
     # argument = (positional_argument | keyword_argument)
     # positional_argument = expression
     # keyword_argument = id ":" expression
-    def parse_filter_expressions(p)
+    def strict2_parse_filter_expressions(p)
       filtername = p.consume(:id)
       filter_args = []
       keyword_args = {}
@@ -121,10 +178,10 @@ module Liquid
       if p.look(:id) && p.look(:colon, 1)
         key = p.consume(:id)
         p.consume(:colon)
-        value = p.expression
+        value = parse_context.safe_parse_expression(p)
         keyword_arguments[key] = value
       else
-        positional_arguments << p.expression
+        positional_arguments << parse_context.safe_parse_expression(p)
       end
     end
 

lib/liquid/variable_lookup.rb

@@ -7,6 +7,10 @@ module Liquid
     attr_reader :name, :lookups
 
     def self.parse(markup, string_scanner = StringScanner.new(""), cache = nil)
+      new(markup, string_scanner, cache)
+    end
+
+    def initialize(markup, string_scanner = StringScanner.new(""), cache = nil)
       lookups = markup.scan(VariableParser)
 
       name = lookups.shift
@@ -17,10 +21,12 @@ module Liquid
           cache,
         )
       end
+      @name = name
 
-      command_flags = 0
+      @lookups       = lookups
+      @command_flags = 0
 
-      lookups.each_index do |i|
+      @lookups.each_index do |i|
         lookup = lookups[i]
         if lookup&.start_with?('[') && lookup&.end_with?(']')
           lookups[i] = Expression.parse(
@@ -29,17 +35,9 @@ module Liquid
             cache,
           )
         elsif COMMAND_METHODS.include?(lookup)
-          command_flags |= 1 << i
+          @command_flags |= 1 << i
         end
       end
-
-      new(name, lookups, command_flags)
-    end
-
-    def initialize(name, lookups, command_flags)
-      @name = name
-      @lookups = lookups
-      @command_flags = command_flags
     end
 
     def lookup_command?(lookup_index)

lib/liquid/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Liquid
-  VERSION = "5.11.0"
+  VERSION = "5.12.0"
 end

performance/benchmark.rb

@@ -4,6 +4,7 @@ require 'benchmark/ips'
 require_relative 'theme_runner'
 
 RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
+Liquid::Environment.default.error_mode = ARGV.first.to_sym if ARGV.first
 
 profiler = ThemeRunner.new
 

performance/memory_profile.rb

@@ -53,6 +53,8 @@ class Profiler
   end
 end
 
+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
+
 runner = ThemeRunner.new
 Profiler.run do |x|
   x.profile('parse') { runner.compile }

performance/profile.rb

@@ -3,6 +3,7 @@
 require 'stackprof'
 require_relative 'theme_runner'
 
+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run
 

performance/unit/expression_benchmark.rb

@@ -6,7 +6,7 @@ require "benchmark/ips"
 
 require 'liquid'
 
-RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
+RubyVM::YJIT.enable
 
 STRING_MARKUPS = [
   "\"foo\"",
@@ -45,14 +45,22 @@ NUMBER_MARKUPS = [
 
 RANGE_MARKUPS = [
   "(1..30)",
+  "(1...30)",
+  "(1..30..5)",
+  "(1.0...30.0)",
+  "(1.........30)",
   "(1..foo)",
   "(foo..30)",
   "(foo..bar)",
+  "(foo...bar...100)",
+  "(foo...bar...100.0)",
 ]
 
 LITERAL_MARKUPS = [
+  nil,
   'nil',
   'null',
+  '',
   'true',
   'false',
   'blank',
@@ -67,39 +75,20 @@ MARKUPS = {
   "range" => RANGE_MARKUPS,
 }
 
-module Liquid
-  Benchmark.ips do |x|
-    x.config(time: 5, warmup: 5)
+Benchmark.ips do |x|
+  x.config(time: 5, warmup: 5)
 
-    ss = StringScanner.new('')
-
-    MARKUPS.each do |type, markups|
-      x.report("#{type} - Liquid::Expression#parse") do
-        markups.each do |markup|
-          ss.string = markup
-          Expression.parse(markup, ss)
-        end
-      end
-
-      x.report("#{type} - Liquid::Parser#expression") do
-        markups.each do |markup|
-          ss.string = markup
-          Parser.new(ss).expression
-        end
-      end
-
-      x.report("#{type} - Liquid::Expression.parse(Parser#expression_string)") do
-        markups.each do |markup|
-          ss.string = markup
-          Expression.parse(Parser.new(ss).expression_string, ss)
-        end
-      end
-    end
-
-    x.report("Liquid::Expression#parse: all") do
-      MARKUPS.values.flatten.each do |markup|
-        Expression.parse(markup)
+  MARKUPS.each do |type, markups|
+    x.report("Liquid::Expression#parse: #{type}") do
+      markups.each do |markup|
+        Liquid::Expression.parse(markup)
       end
     end
   end
+
+  x.report("Liquid::Expression#parse: all") do
+    MARKUPS.values.flatten.each do |markup|
+      Liquid::Expression.parse(markup)
+    end
+  end
 end

performance/unit/lexer_benchmark.rb

@@ -6,7 +6,7 @@ require "benchmark/ips"
 
 require 'liquid'
 
-RubyVM::YJIT.enable if defined?(RubyVM::YJIT)
+RubyVM::YJIT.enable
 
 EXPRESSIONS = [
   "foo[1..2].baz",
@@ -31,12 +31,11 @@ EXPRESSIONS = [
 
 Benchmark.ips do |x|
   x.config(time: 10, warmup: 5)
-  ss = StringScanner.new('')
 
   x.report("Liquid::Lexer#tokenize") do
     EXPRESSIONS.each do |expr|
-      ss.string = expr
-      Liquid::Lexer.tokenize(ss)
+      l = Liquid::Lexer.new(expr)
+      l.tokenize
     end
   end
 

spec/ruby_liquid_lax.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Liquid Spec Adapter for Shopify/liquid with lax parsing mode
+#
+# Run with: bundle exec liquid-spec run spec/ruby_liquid_lax.rb
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'liquid'
+
+LiquidSpec.configure do |config|
+  config.features = [:core, :lax_parsing]
+end
+
+# Compile a template string into a Liquid::Template
+LiquidSpec.compile do |ctx, source, options|
+  # Force lax mode
+  options = options.merge(error_mode: :lax)
+  ctx[:template] = Liquid::Template.parse(source, **options)
+end
+
+# Render a compiled template with the given context
+LiquidSpec.render do |ctx, assigns, options|
+  registers = Liquid::Registers.new(options[:registers] || {})
+
+  context = Liquid::Context.build(
+    static_environments: assigns,
+    registers: registers,
+    rethrow_errors: options[:strict_errors],
+  )
+
+  context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
+
+  ctx[:template].render(context)
+end

spec/ruby_liquid_yjit.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-# Liquid Spec Adapter for Shopify/liquid with YJIT + ActiveSupport
+# Liquid Spec Adapter for Shopify/liquid with YJIT + strict mode + ActiveSupport
 #
 # Run with: bundle exec liquid-spec run spec/ruby_liquid_yjit.rb
 
@@ -20,6 +20,8 @@ end
 
 # Compile a template string into a Liquid::Template
 LiquidSpec.compile do |ctx, source, options|
+  # Force strict mode
+  options = { error_mode: :strict }.merge(options)
   ctx[:template] = Liquid::Template.parse(source, **options)
 end
 

test/integration/assign_test.rb

@@ -35,28 +35,17 @@ class AssignTest < Minitest::Test
     )
   end
 
-  def test_assign_boolean_expression_assignment
-    assert_template_result(
-      'it rendered',
-      <<~LIQUID,
-        {%- assign should_render = a == 0 or (b == 1 and c == 2) -%}
-        {%- if should_render -%}
-          it rendered
-        {%- endif -%}
-      LIQUID
-      { 'b' => 1, 'c' => 2 },
-    )
-  end
-
   def test_assign_syntax_error
     assert_match_syntax_error(/assign/, '{% assign foo not values %}.')
   end
 
-  def test_assign_throws_on_unsupported_syntax
+  def test_assign_uses_error_mode
     assert_match_syntax_error(
-      "Expected close_round but found pipe",
+      "Expected dotdot but found pipe in ",
       "{% assign foo = ('X' | downcase) %}",
+      error_mode: :strict,
     )
+    assert_template_result("", "{% assign foo = ('X' | downcase) %}", error_mode: :lax)
   end
 
   def test_expression_with_whitespace_in_square_brackets

test/integration/context_test.rb

@@ -632,9 +632,11 @@ class ContextTest < Minitest::Test
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    context = Context.new
-    context.key?('unknown')
-    assert_empty(context.errors)
+    with_error_modes(:strict) do
+      context = Context.new
+      context.key?('unknown')
+      assert_empty(context.errors)
+    end
   end
 
   def test_key_lookup_will_raise_for_missing_keys_when_strict_variables_is_enabled

test/integration/error_handling_test.rb

@@ -67,11 +67,20 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_unrecognized_operator
-    assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+    with_error_modes(:strict) do
+      assert_raises(SyntaxError) do
+        Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+      end
     end
   end
 
+  def test_lax_unrecognized_operator
+    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
+    assert_equal(' Liquid error: Unknown operator =! ', template.render)
+    assert_equal(1, template.errors.size)
+    assert_equal(Liquid::ArgumentError, template.errors.first.class)
+  end
+
   def test_with_line_numbers_adds_numbers_to_parser_errors
     source = <<~LIQUID
       foobar
@@ -95,6 +104,25 @@ class ErrorHandlingTest < Minitest::Test
     assert_match_syntax_error(/Liquid syntax error \(line 3\)/, source)
   end
 
+  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
+    template = Liquid::Template.parse(
+      '
+        foobar
+
+        {% if 1 =! 2 %}ok{% endif %}
+
+        bla
+            ',
+      error_mode: :warn,
+      line_numbers: true,
+    )
+
+    assert_equal(
+      ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
+      template.warnings.map(&:message),
+    )
+  end
+
   def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
     err = assert_raises(SyntaxError) do
       Liquid::Template.parse(
@@ -105,6 +133,7 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
                 ',
+        error_mode: :strict,
         line_numbers: true,
       )
     end
@@ -128,16 +157,34 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_strict_error_messages
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
+      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
     end
     assert_equal('Liquid syntax error: Unexpected character = in "1 =! 2"', err.message)
 
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}')
+      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
     end
     assert_equal('Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message)
   end
 
+  def test_warnings
+    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
+    assert_equal(3, template.warnings.size)
+    assert_equal('Unexpected character ~ in "~~~"', template.warnings[0].to_s(false))
+    assert_equal('Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false))
+    assert_equal('Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false))
+    assert_equal('', template.render)
+  end
+
+  def test_warning_line_numbers
+    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
+    assert_equal('Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message)
+    assert_equal('Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message)
+    assert_equal('Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message)
+    assert_equal(3, template.warnings.size)
+    assert_equal([1, 2, 3], template.warnings.map(&:line_number))
+  end
+
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
   def test_exceptions_propagate
     assert_raises(Exception) do

test/integration/expression_test.rb

@@ -27,6 +27,11 @@ class ExpressionTest < Minitest::Test
     assert_template_result("-17.42", "{{ -17.42 }}")
     assert_template_result("2.5", "{{ 2.5 }}")
 
+    with_error_modes(:lax) do
+      assert_expression_result(0.0, "0.....5")
+      assert_expression_result(0.0, "-0..1")
+    end
+
     assert_expression_result(1.5, "1.5")
 
     # this is a unfortunate quirky behavior of Liquid
@@ -46,11 +51,24 @@ class ExpressionTest < Minitest::Test
       "{{ (false..true) }}",
     )
     assert_match_syntax_error(
-      "Liquid syntax error (line 1): Invalid expression type '1..2' in range expression",
+      "Liquid syntax error (line 1): Invalid expression type '(1..2)' in range expression",
       "{{ ((1..2)..3) }}",
     )
   end
 
+  def test_quirky_negative_sign_expression_markup
+    result = Expression.parse("-", nil)
+    assert(result.is_a?(VariableLookup))
+    assert_equal("-", result.name)
+
+    # for this template, the expression markup is "-"
+    assert_template_result(
+      "",
+      "{{ - 'theme.css' - }}",
+      error_mode: :lax,
+    )
+  end
+
   def test_expression_cache
     skip("Liquid-C does not support Expression caching") if defined?(Liquid::C) && Liquid::C.enabled
 
@@ -67,7 +85,7 @@ class ExpressionTest < Minitest::Test
     Liquid::Template.parse(template, expression_cache: cache).render
 
     assert_equal(
-      [],
+      ["1", "2", "x", "y"],
       cache.to_a.map { _1[0] }.sort,
     )
   end
@@ -91,7 +109,7 @@ class ExpressionTest < Minitest::Test
     cache = parse_context.instance_variable_get(:@expression_cache)
 
     assert_equal(
-      [],
+      ["1", "2", "x", "y"],
       cache.to_a.map { _1[0] }.sort,
     )
   end
@@ -112,7 +130,7 @@ class ExpressionTest < Minitest::Test
     Liquid::Template.parse(template, expression_cache: cache).render
 
     assert_equal(
-      [],
+      ["1", "2", "x", "y"],
       cache.to_a.map { _1[0] }.sort,
     )
   end
@@ -134,30 +152,30 @@ class ExpressionTest < Minitest::Test
     assert(parse_context.instance_variable_get(:@expression_cache).nil?)
   end
 
-  def test_parser_expression_with_variable_lookup
+  def test_safe_parse_with_variable_lookup
     parse_context = Liquid::ParseContext.new
     parser = parse_context.new_parser('product.title')
-    result = parser.expression
+    result = Liquid::Expression.safe_parse(parser)
 
     assert_instance_of(Liquid::VariableLookup, result)
     assert_equal('product', result.name)
     assert_equal(['title'], result.lookups)
   end
 
-  def test_parser_expression_with_number
+  def test_safe_parse_with_number
     parse_context = Liquid::ParseContext.new
     parser = parse_context.new_parser('42')
-    result = parser.expression
+    result = Liquid::Expression.safe_parse(parser)
 
     assert_equal(42, result)
   end
 
-  def test_parser_expression_raises_syntax_error_for_invalid_expression
+  def test_safe_parse_raises_syntax_error_for_invalid_expression
     parse_context = Liquid::ParseContext.new
     parser = parse_context.new_parser('')
 
     error = assert_raises(Liquid::SyntaxError) do
-      parser.expression
+      Liquid::Expression.safe_parse(parser)
     end
 
     assert_match(/is not a valid expression/, error.message)

test/integration/parsing_quirks_test.rb

@@ -31,24 +31,58 @@ class ParsingQuirksTest < Minitest::Test
   def test_error_on_empty_filter
     assert(Template.parse("{{test}}"))
 
-    assert_raises(Liquid::SyntaxError) { Template.parse("{{|test}}") }
-    assert_raises(Liquid::SyntaxError) { Template.parse("{{test |a|b|}}") }
+    with_error_modes(:lax) do
+      assert(Template.parse("{{|test}}"))
+    end
+
+    with_error_modes(:strict) do
+      assert_raises(SyntaxError) { Template.parse("{{|test}}") }
+      assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
+    end
   end
 
-  def test_supported_parens
-    markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-    out = Template.parse("{% if #{markup} %} YES {% endif %}").render({ 'b' => 'bar', 'c' => 'baz' })
-    assert_equal(' YES ', out)
+  def test_meaningless_parens_error
+    with_error_modes(:strict) do
+      assert_raises(SyntaxError) do
+        markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
+    end
   end
 
   def test_unexpected_characters_syntax_error
-    assert_raises(SyntaxError) do
-      markup = "true && false"
-      Template.parse("{% if #{markup} %} YES {% endif %}")
+    with_error_modes(:strict) do
+      assert_raises(SyntaxError) do
+        markup = "true && false"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
+      assert_raises(SyntaxError) do
+        markup = "false || true"
+        Template.parse("{% if #{markup} %} YES {% endif %}")
+      end
     end
-    assert_raises(SyntaxError) do
+  end
+
+  def test_no_error_on_lax_empty_filter
+    assert(Template.parse("{{test |a|b|}}", error_mode: :lax))
+    assert(Template.parse("{{test}}", error_mode: :lax))
+    assert(Template.parse("{{|test|}}", error_mode: :lax))
+  end
+
+  def test_meaningless_parens_lax
+    with_error_modes(:lax) do
+      assigns = { 'b' => 'bar', 'c' => 'baz' }
+      markup  = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
+    end
+  end
+
+  def test_unexpected_characters_silently_eat_logic_lax
+    with_error_modes(:lax) do
+      markup = "true && false"
+      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
       markup = "false || true"
-      Template.parse("{% if #{markup} %} YES {% endif %}")
+      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
     end
   end
 
@@ -58,6 +92,32 @@ class ParsingQuirksTest < Minitest::Test
     end
   end
 
+  def test_unanchored_filter_arguments
+    with_error_modes(:lax) do
+      assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
+
+      assert_template_result('x', "{{ 'X' | downcase) }}")
+
+      # After the messed up quotes a filter without parameters (reverse) should work
+      # but one with parameters (remove) shouldn't be detected.
+      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
+      assert_template_result('hi ', "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
+    end
+  end
+
+  def test_invalid_variables_work
+    with_error_modes(:lax) do
+      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
+      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
+    end
+  end
+
+  def test_extra_dots_in_ranges
+    with_error_modes(:lax) do
+      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
+    end
+  end
+
   def test_blank_variable_markup
     assert_template_result('', "{{}}")
   end
@@ -71,4 +131,24 @@ class ParsingQuirksTest < Minitest::Test
   def test_contains_in_id
     assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', { 'containsallshipments' => true })
   end
+
+  def test_incomplete_expression
+    with_error_modes(:lax) do
+      assert_template_result("false", "{{ false - }}")
+      assert_template_result("false", "{{ false > }}")
+      assert_template_result("false", "{{ false < }}")
+      assert_template_result("false", "{{ false = }}")
+      assert_template_result("false", "{{ false ! }}")
+      assert_template_result("false", "{{ false 1 }}")
+      assert_template_result("false", "{{ false a }}")
+
+      assert_template_result("false", "{% liquid assign foo = false -\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false >\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false <\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false =\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false !\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false 1\n%}{{ foo }}")
+      assert_template_result("false", "{% liquid assign foo = false a\n%}{{ foo }}")
+    end
+  end
 end # ParsingQuirksTest

test/integration/standard_filter_test.rb

@@ -164,6 +164,13 @@ class StandardFiltersTest < Minitest::Test
     assert_equal(['A', 'Z'], @filters.split('A1Z', 1))
   end
 
+  def test_squish_filter
+    assert_equal("foo bar boo", Liquid::Template.parse(%({{ " foo   bar
+\t   boo   " | squish }})).render)
+    assert_equal("", Liquid::Template.parse('{{ nil | squish }}').render)
+    assert_equal("", Liquid::Template.parse('{{ " " | squish }}').render)
+  end
+
   def test_escape
     assert_equal('&lt;strong&gt;', @filters.escape('<strong>'))
     assert_equal('1', @filters.escape(1))

test/integration/tags/cycle_tag_test.rb

@@ -91,21 +91,28 @@ class CycleTagTest < Minitest::Test
     assert_match(/Syntax Error in 'cycle' - Valid syntax: cycle \[name :\] var/, error.message)
   end
 
-  def test_cycle_tag_unsupported_legacy_quirk
+  def test_cycle_tag_with_error_mode
     # QuotedFragment is more permissive than what Parser#expression allows.
     template1 = "{% assign 5 = 'b' %}{% cycle .5, .4 %}"
     template2 = "{% cycle .5: 'a', 'b' %}"
 
-    error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
-    error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
+    with_error_modes(:lax, :strict) do
+      assert_template_result("b", template1)
+      assert_template_result("a", template2)
+    end
 
-    expected_error = /Liquid syntax error: \[:dot, "."\] is not a valid expression/
+    with_error_modes(:strict2) do
+      error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
+      error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
 
-    assert_match(expected_error, error1.message)
-    assert_match(expected_error, error2.message)
+      expected_error = /Liquid syntax error: \[:dot, "."\] is not a valid expression/
+
+      assert_match(expected_error, error1.message)
+      assert_match(expected_error, error2.message)
+    end
   end
 
-  def test_cycle_with_trailing_elements_legacy_syntax
+  def test_cycle_with_trailing_elements
     assignments = "{% assign a = 'A' %}{% assign n = 'N' %}"
 
     template1 = "#{assignments}{% cycle       'a'  'b', 'c' %}"
@@ -114,19 +121,29 @@ class CycleTagTest < Minitest::Test
     template4 = "#{assignments}{% cycle n  e: 'a', 'b', 'c' %}"
     template5 = "#{assignments}{% cycle n  e  'a', 'b', 'c' %}"
 
-    error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
-    error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
-    error3 = assert_raises(Liquid::SyntaxError) { Template.parse(template3) }
-    error4 = assert_raises(Liquid::SyntaxError) { Template.parse(template4) }
-    error5 = assert_raises(Liquid::SyntaxError) { Template.parse(template5) }
+    with_error_modes(:lax, :strict) do
+      assert_template_result("a", template1)
+      assert_template_result("a", template2)
+      assert_template_result("a", template3)
+      assert_template_result("N", template4)
+      assert_template_result("N", template5)
+    end
 
-    expected_error = /Expected end_of_string but found/
+    with_error_modes(:strict2) do
+      error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
+      error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
+      error3 = assert_raises(Liquid::SyntaxError) { Template.parse(template3) }
+      error4 = assert_raises(Liquid::SyntaxError) { Template.parse(template4) }
+      error5 = assert_raises(Liquid::SyntaxError) { Template.parse(template5) }
 
-    assert_match(expected_error, error1.message)
-    assert_match(expected_error, error2.message)
-    assert_match(expected_error, error3.message)
-    assert_match(expected_error, error4.message)
-    assert_match(expected_error, error5.message)
+      expected_error = /Expected end_of_string but found/
+
+      assert_match(expected_error, error1.message)
+      assert_match(expected_error, error2.message)
+      assert_match(expected_error, error3.message)
+      assert_match(expected_error, error4.message)
+      assert_match(expected_error, error5.message)
+    end
   end
 
   def test_cycle_name_with_invalid_expression
@@ -136,8 +153,14 @@ class CycleTagTest < Minitest::Test
       {% endfor %}
     LIQUID
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-    assert_match(/Unexpected character =/, error.message)
+    with_error_modes(:lax, :strict) do
+      refute_nil(Template.parse(template))
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 
   def test_cycle_variable_with_invalid_expression
@@ -147,7 +170,13 @@ class CycleTagTest < Minitest::Test
       {% endfor %}
     LIQUID
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-    assert_match(/Unexpected character =/, error.message)
+    with_error_modes(:lax, :strict) do
+      refute_nil(Template.parse(template))
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 end

test/integration/tags/if_else_tag_test.rb

@@ -147,6 +147,28 @@ class IfElseTagTest < Minitest::Test
     assert_raises(SyntaxError) { assert_template_result('', '{% if %}') }
   end
 
+  def test_if_with_custom_condition
+    original_op = Condition.operators['contains']
+    Condition.operators['contains'] = :[]
+
+    assert_template_result('yes', %({% if 'bob' contains 'o' %}yes{% endif %}))
+    assert_template_result('no', %({% if 'bob' contains 'f' %}yes{% else %}no{% endif %}))
+  ensure
+    Condition.operators['contains'] = original_op
+  end
+
+  def test_operators_are_ignored_unless_isolated
+    original_op = Condition.operators['contains']
+    Condition.operators['contains'] = :[]
+
+    assert_template_result(
+      'yes',
+      %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}),
+    )
+  ensure
+    Condition.operators['contains'] = original_op
+  end
+
   def test_operators_are_whitelisted
     assert_raises(SyntaxError) do
       assert_template_result('', %({% if 1 or throw or or 1 %}yes{% endif %}))

test/integration/tags/include_tag_test.rb

@@ -204,13 +204,23 @@ class IncludeTagTest < Minitest::Test
     )
   end
 
-  def test_parsing_errors_for_legacy_quirk
-    assert_syntax_error(
-      '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-    )
-    assert_syntax_error(
-      '{% include "snippet" | filter %}',
-    )
+  def test_strict2_parsing_errors
+    with_error_modes(:lax, :strict) do
+      assert_template_result(
+        'hello value1 value2',
+        '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
+        partials: { 'snippet' => 'hello {{ arg1 }} {{ arg2 }}' },
+      )
+    end
+
+    with_error_modes(:strict2) do
+      assert_syntax_error(
+        '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
+      )
+      assert_syntax_error(
+        '{% include "snippet" | filter %}',
+      )
+    end
   end
 
   def test_optional_commas
@@ -291,10 +301,16 @@ class IncludeTagTest < Minitest::Test
     env = Liquid::Environment.build(file_system: TestFileSystem.new)
 
     assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", environment: env).render!("template" => '{{ "X" || downcase }}')
+      Template.parse("{% include template %}", error_mode: :strict, environment: env).render!("template" => '{{ "X" || downcase }}')
+    end
+    with_error_modes(:lax) do
+      assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: true, environment: env).render!("template" => '{{ "X" || downcase }}'))
     end
     assert_raises(Liquid::SyntaxError) do
-      Template.parse("{% include template %}", include_options_blacklist: [:locale], environment: env).render!("template" => '{{ "X" || downcase }}')
+      Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:locale], environment: env).render!("template" => '{{ "X" || downcase }}')
+    end
+    with_error_modes(:lax) do
+      assert_equal('x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode], environment: env).render!("template" => '{{ "X" || downcase }}'))
     end
   end
 
@@ -349,7 +365,7 @@ class IncludeTagTest < Minitest::Test
       file_system: StubFileSystem.new('simple' => 'simple'),
     )
 
-    template = Liquid::Template.parse("{% include 'simple' %}", environment: env)
+    template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn, environment: env)
     template.render(nil, strict_variables: true)
 
     assert_equal([], template.errors)
@@ -388,21 +404,39 @@ class IncludeTagTest < Minitest::Test
   def test_include_template_with_invalid_expression
     template = "{% include foo=>bar %}"
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-    assert_match(/Unexpected character =/, error.message)
+    with_error_modes(:lax, :strict) do
+      refute_nil(Template.parse(template))
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 
   def test_include_with_invalid_expression
     template = '{% include "snippet" with foo=>bar %}'
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-    assert_match(/Unexpected character =/, error.message)
+    with_error_modes(:lax, :strict) do
+      refute_nil(Template.parse(template))
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 
   def test_include_attribute_with_invalid_expression
     template = '{% include "snippet", key: foo=>bar %}'
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-    assert_match(/Unexpected character =/, error.message)
+    with_error_modes(:lax, :strict) do
+      refute_nil(Template.parse(template))
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 end # IncludeTagTest

test/integration/tags/render_tag_test.rb

@@ -105,13 +105,23 @@ class RenderTagTest < Minitest::Test
     assert_syntax_error("{% assign name = 'snippet' %}{% render name %}")
   end
 
-  def test_parsing_errors_legacy_syntax
-    assert_syntax_error(
-      '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
-    )
-    assert_syntax_error(
-      '{% render "snippet" | filter %}',
-    )
+  def test_strict2_parsing_errors
+    with_error_modes(:lax, :strict) do
+      assert_template_result(
+        'hello value1 value2',
+        '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
+        partials: { 'snippet' => 'hello {{ arg1 }} {{ arg2 }}' },
+      )
+    end
+
+    with_error_modes(:strict2) do
+      assert_syntax_error(
+        '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
+      )
+      assert_syntax_error(
+        '{% render "snippet" | filter %}',
+      )
+    end
   end
 
   def test_optional_commas
@@ -307,13 +317,27 @@ class RenderTagTest < Minitest::Test
 
   def test_render_with_invalid_expression
     template = '{% render "snippet" with foo=>bar %}'
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-    assert_match(/Unexpected character =/, error.message)
+
+    with_error_modes(:lax, :strict) do
+      refute_nil(Template.parse(template))
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 
   def test_render_attribute_with_invalid_expression
     template = '{% render "snippet", key: foo=>bar %}'
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
-    assert_match(/Unexpected character =/, error.message)
+
+    with_error_modes(:lax, :strict) do
+      refute_nil(Template.parse(template))
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 end

test/integration/tags/table_row_test.rb

@@ -188,6 +188,29 @@ class TableRowTest < Minitest::Test
     assert_template_result(expected_output, template)
   end
 
+  def test_table_row_renders_correct_error_message_for_invalid_parameters
+    assert_template_result(
+      "Liquid error (line 1): invalid integer",
+      '{% tablerow n in (1...10) limit:true %} {{n}} {% endtablerow %}',
+      error_mode: :warn,
+      render_errors: true,
+    )
+
+    assert_template_result(
+      "Liquid error (line 1): invalid integer",
+      '{% tablerow n in (1...10) offset:true %} {{n}} {% endtablerow %}',
+      error_mode: :warn,
+      render_errors: true,
+    )
+
+    assert_template_result(
+      "Liquid error (line 1): invalid integer",
+      '{% tablerow n in (1...10) cols:true %} {{n}} {% endtablerow %}',
+      render_errors: true,
+      error_mode: :warn,
+    )
+  end
+
   def test_table_row_handles_interrupts
     assert_template_result(
       "<tr class=\"row1\">\n<td class=\"col1\"> 1 </td></tr>\n",
@@ -236,7 +259,7 @@ class TableRowTest < Minitest::Test
     )
   end
 
-  def test_tablerow_with_cols_attribute
+  def test_tablerow_with_cols_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..6) cols: 3 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -247,10 +270,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">4</td><td class="col2">5</td><td class="col3">6</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template)
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template)
+    end
   end
 
-  def test_tablerow_with_limit_attribute
+  def test_tablerow_with_limit_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..10) limit: 3 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -260,10 +285,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template)
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template)
+    end
   end
 
-  def test_tablerow_with_offset_attribute
+  def test_tablerow_with_offset_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..5) offset: 2 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -273,10 +300,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">3</td><td class="col2">4</td><td class="col3">5</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template)
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template)
+    end
   end
 
-  def test_tablerow_with_range_attribute
+  def test_tablerow_with_range_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..3) range: (1..10) %}{{ i }}{% endtablerow %}
     LIQUID
@@ -286,10 +315,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template)
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template)
+    end
   end
 
-  def test_tablerow_with_multiple_attributes
+  def test_tablerow_with_multiple_attributes_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..10) cols: 2, limit: 4, offset: 1 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -300,10 +331,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">4</td><td class="col2">5</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template)
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template)
+    end
   end
 
-  def test_tablerow_with_variable_collection
+  def test_tablerow_with_variable_collection_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in numbers cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -314,10 +347,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
+    end
   end
 
-  def test_tablerow_with_dotted_access
+  def test_tablerow_with_dotted_access_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in obj.numbers cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -328,10 +363,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
+    end
   end
 
-  def test_tablerow_with_bracketed_access
+  def test_tablerow_with_bracketed_access_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in obj["numbers"] cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -341,10 +378,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">10</td><td class="col2">20</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
+    end
   end
 
-  def test_tablerow_without_attributes
+  def test_tablerow_without_attributes_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..3) %}{{ i }}{% endtablerow %}
     LIQUID
@@ -354,24 +393,30 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    assert_template_result(expected, template)
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template)
+    end
   end
 
-  def test_tablerow_without_in_keyword
+  def test_tablerow_without_in_keyword_in_strict2_mode
     template = '{% tablerow i (1..10) %}{{ i }}{% endtablerow %}'
 
-    error = assert_raises(SyntaxError) { Template.parse(template) }
-    assert_equal("Liquid syntax error: For loops require an 'in' clause in \"i (1..10)\"", error.message)
+    with_error_modes(:strict2) do
+      error = assert_raises(SyntaxError) { Template.parse(template) }
+      assert_equal("Liquid syntax error: For loops require an 'in' clause in \"i (1..10)\"", error.message)
+    end
   end
 
-  def test_tablerow_with_multiple_invalid_attributes_reports_first
+  def test_tablerow_with_multiple_invalid_attributes_reports_first_in_strict2_mode
     template = '{% tablerow i in (1..10) invalid1: 5, invalid2: 10 %}{{ i }}{% endtablerow %}'
 
-    error = assert_raises(SyntaxError) { Template.parse(template) }
-    assert_equal("Liquid syntax error: Invalid attribute 'invalid1' in tablerow loop. Valid attributes are cols, limit, offset, and range in \"i in (1..10) invalid1: 5, invalid2: 10\"", error.message)
+    with_error_modes(:strict2) do
+      error = assert_raises(SyntaxError) { Template.parse(template) }
+      assert_equal("Liquid syntax error: Invalid attribute 'invalid1' in tablerow loop. Valid attributes are cols, limit, offset, and range in \"i in (1..10) invalid1: 5, invalid2: 10\"", error.message)
+    end
   end
 
-  def test_tablerow_with_empty_collection
+  def test_tablerow_with_empty_collection_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in empty_array cols: 2 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -381,18 +426,43 @@ class TableRowTest < Minitest::Test
       </tr>
     OUTPUT
 
-    assert_template_result(expected, template, { 'empty_array' => [] })
+    with_error_modes(:strict2) do
+      assert_template_result(expected, template, { 'empty_array' => [] })
+    end
   end
 
-  def test_tablerow_with_invalid_attribute
+  def test_tablerow_with_invalid_attribute_strict_vs_strict2
     template = '{% tablerow i in (1..5) invalid_attr: 10 %}{{ i }}{% endtablerow %}'
-    error = assert_raises(SyntaxError) { Template.parse(template) }
-    assert_match(/Invalid attribute 'invalid_attr'/, error.message)
+
+    expected = <<~OUTPUT
+      <tr class="row1">
+      <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td><td class="col4">4</td><td class="col5">5</td></tr>
+    OUTPUT
+
+    with_error_modes(:lax, :strict) do
+      assert_template_result(expected, template)
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(SyntaxError) { Template.parse(template) }
+      assert_match(/Invalid attribute 'invalid_attr'/, error.message)
+    end
   end
 
-  def test_tablerow_with_invalid_expression
+  def test_tablerow_with_invalid_expression_strict_vs_strict2
     template = '{% tablerow i in (1..5) limit: foo=>bar %}{{ i }}{% endtablerow %}'
-    error = assert_raises(SyntaxError) { Template.parse(template) }
-    assert_match(/Unexpected character =/, error.message)
+
+    with_error_modes(:lax, :strict) do
+      expected = <<~OUTPUT
+        <tr class="row1">
+        </tr>
+      OUTPUT
+      assert_template_result(expected, template)
+    end
+
+    with_error_modes(:strict2) do
+      error = assert_raises(SyntaxError) { Template.parse(template) }
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 end

test/integration/template_test.rb

@@ -44,6 +44,16 @@ class TemplateTest < Minitest::Test
     assert_equal('from instance assigns', t.parse("{{ foo }}").render!)
   end
 
+  def test_warnings_is_not_exponential_time
+    str = "false"
+    100.times do
+      str = "{% if true %}true{% else %}#{str}{% endif %}"
+    end
+
+    t = Template.parse(str)
+    assert_equal([], Timeout.timeout(1) { t.warnings })
+  end
+
   def test_instance_assigns_persist_on_same_template_parsing_between_renders
     t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
     assert_equal('foo', t.render!)
@@ -169,6 +179,86 @@ class TemplateTest < Minitest::Test
     assert_equal("すごい", t.render)
   end
 
+  def test_cumulative_render_score_limit_across_render_tags
+    file_system = StubFileSystem.new(
+      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
+    )
+    environment = Liquid::Environment.build(file_system: file_system)
+
+    # Without cumulative limit, all 5 partials render successfully
+    t = Template.parse(
+      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
+      environment: environment,
+    )
+    unlimited_output = t.render!
+    total_cumulative = t.resource_limits.cumulative_render_score
+
+    # With cumulative limit set below the total, rendering stops early
+    t2 = Template.parse(
+      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
+      environment: environment,
+    )
+    t2.resource_limits.cumulative_render_score_limit = total_cumulative / 2
+    limited_output = t2.render
+    assert(t2.resource_limits.reached?)
+    assert_operator(limited_output.length, :<, unlimited_output.length)
+  end
+
+  def test_cumulative_render_score_limit_raises_on_render_bang
+    file_system = StubFileSystem.new(
+      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
+    )
+    environment = Liquid::Environment.build(file_system: file_system)
+    t = Template.parse(
+      '{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}{% render "loop" %}',
+      environment: environment,
+    )
+    t.resource_limits.cumulative_render_score_limit = 20
+    assert_raises(Liquid::MemoryError) do
+      t.render!
+    end
+  end
+
+  def test_cumulative_assign_score_limit_across_include_tags
+    file_system = StubFileSystem.new(
+      'assign_partial' => '{% assign x = "a long string value here" %}',
+    )
+    environment = Liquid::Environment.build(file_system: file_system)
+
+    # Without cumulative limit, all 5 partials render
+    t = Template.parse(
+      '{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}',
+      environment: environment,
+    )
+    t.render!
+    total_cumulative = t.resource_limits.cumulative_assign_score
+
+    # With cumulative limit set below the total, rendering stops early
+    t2 = Template.parse(
+      '{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}{% include "assign_partial" %}',
+      environment: environment,
+    )
+    t2.resource_limits.cumulative_assign_score_limit = total_cumulative / 2
+    t2.render
+    assert(t2.resource_limits.reached?)
+  end
+
+  def test_cumulative_render_score_tracks_across_partials_without_limit
+    file_system = StubFileSystem.new(
+      'loop' => '{% for a in (1..10) %} foo {% endfor %}',
+    )
+    environment = Liquid::Environment.build(file_system: file_system)
+    t = Template.parse(
+      '{% render "loop" %}{% render "loop" %}{% render "loop" %}',
+      environment: environment,
+    )
+    t.render!
+    assert(
+      t.resource_limits.cumulative_render_score > t.resource_limits.render_score,
+      "cumulative should exceed per-template score after multiple partials",
+    )
+  end
+
   def test_default_resource_limits_unaffected_by_render_with_context
     context = Context.new
     t = Template.parse("{% for a in (1..100) %}x{% assign foo = 1 %} {% endfor %}")
@@ -249,7 +339,7 @@ class TemplateTest < Minitest::Test
   end
 
   def test_nil_value_does_not_raise
-    t      = Template.parse("some{{x}}thing")
+    t      = Template.parse("some{{x}}thing", error_mode: :strict)
     result = t.render!({ 'x' => nil }, strict_variables: true)
 
     assert_equal(0, t.errors.count)

test/integration/variable_test.rb

@@ -11,24 +11,6 @@ class VariableTest < Minitest::Test
     assert_template_result('worked wonderfully', "{{test}}", { 'test' => 'worked wonderfully' })
   end
 
-  def test_equality
-    assert_template_result('true', "{{ 5 == 5 }}")
-    assert_template_result('false', "{{ 5 == 3 }}")
-  end
-
-  def test_comparison
-    assert_template_result('true', "{{ 5 > 3 }}")
-    assert_template_result('false', "{{ 5 < 3 }}")
-  end
-
-  def test_expression_piped_into_filter
-    assert_template_result('TRUE', "{{ 5 == 5 | upcase }}")
-  end
-
-  def test_expression_used_as_filter_argument
-    assert_template_result('A: TRUE', "{{ 'a: $a' | replace: '$a', 5 == 5 | upcase }}")
-  end
-
   def test_variable_render_calls_to_liquid
     assert_template_result('foobar', '{{ foo }}', { 'foo' => ThingWithToLiquid.new })
   end
@@ -194,33 +176,102 @@ class VariableTest < Minitest::Test
     )
   end
 
+  def test_variable_lookup_should_not_hang_with_invalid_syntax
+    Timeout.timeout(1) do
+      assert_template_result(
+        'bar',
+        "{{['foo'}}",
+        {
+          'foo' => 'bar',
+        },
+        error_mode: :lax,
+      )
+    end
+
+    very_long_key = "1234567890" * 100
+
+    template_list = [
+      "{{['#{very_long_key}']}}", # valid
+      "{{['#{very_long_key}'}}", # missing closing bracket
+      "{{[['#{very_long_key}']}}", # extra open bracket
+    ]
+
+    template_list.each do |template|
+      Timeout.timeout(1) do
+        assert_template_result(
+          'bar',
+          template,
+          {
+            very_long_key => 'bar',
+          },
+          error_mode: :lax,
+        )
+      end
+    end
+  end
+
   def test_filter_with_single_trailing_comma
     template = '{{ "hello" | append: "world", }}'
 
-    assert_template_result('helloworld', template)
+    with_error_modes(:strict) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/is not a valid expression/, error.message)
+    end
+
+    with_error_modes(:strict2) do
+      assert_template_result('helloworld', template)
+    end
   end
 
   def test_multiple_filters_with_trailing_commas
     template = '{{ "hello" | append: "1", | append: "2", }}'
 
-    assert_template_result('hello12', template)
+    with_error_modes(:strict) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/is not a valid expression/, error.message)
+    end
+
+    with_error_modes(:strict2) do
+      assert_template_result('hello12', template)
+    end
   end
 
   def test_filter_with_colon_but_no_arguments
     template = '{{ "test" | upcase: }}'
 
-    assert_template_result('TEST', template)
+    with_error_modes(:strict) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/is not a valid expression/, error.message)
+    end
+
+    with_error_modes(:strict2) do
+      assert_template_result('TEST', template)
+    end
   end
 
   def test_filter_chain_with_colon_no_args
     template = '{{ "test" | append: "x" | upcase: }}'
 
-    assert_template_result('TESTX', template)
+    with_error_modes(:strict) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/is not a valid expression/, error.message)
+    end
+
+    with_error_modes(:strict2) do
+      assert_template_result('TESTX', template)
+    end
   end
 
   def test_combining_trailing_comma_and_empty_args
     template = '{{ "test" | append: "x", | upcase: }}'
 
-    assert_template_result('TESTX', template)
+    with_error_modes(:strict) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+      assert_match(/is not a valid expression/, error.message)
+    end
+
+    with_error_modes(:strict2) do
+      assert_template_result('TESTX', template)
+    end
   end
 end

test/test_helper.rb

@@ -8,6 +8,13 @@ $LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
 require 'liquid.rb'
 require 'liquid/profiler'
 
+mode = :strict
+if (env_mode = ENV['LIQUID_PARSER_MODE'])
+  puts "-- #{env_mode.upcase} ERROR MODE"
+  mode = env_mode.to_sym
+end
+Liquid::Environment.default.error_mode = mode
+
 if Minitest.const_defined?('Test')
   # We're on Minitest 5+. Nothing to do here.
 else
@@ -27,27 +34,27 @@ module Minitest
 
     def assert_template_result(
       expected, template, assigns = {},
-      message: nil, partials: nil, render_errors: false,
+      message: nil, partials: nil, error_mode: Liquid::Environment.default.error_mode, render_errors: false,
       template_factory: nil
     )
       file_system = StubFileSystem.new(partials || {})
       environment = Liquid::Environment.build(file_system: file_system)
-      template = Liquid::Template.parse(template, line_numbers: true, environment: environment)
+      template = Liquid::Template.parse(template, line_numbers: true, error_mode: error_mode&.to_sym, environment: environment)
       registers = Liquid::Registers.new(file_system: file_system, template_factory: template_factory)
       context = Liquid::Context.build(static_environments: assigns, rethrow_errors: !render_errors, registers: registers, environment: environment)
       output = template.render(context)
       assert_equal(expected, output, message)
     end
 
-    def assert_match_syntax_error(match, template)
+    def assert_match_syntax_error(match, template, error_mode: nil)
       exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template, line_numbers: true).render
+        Template.parse(template, line_numbers: true, error_mode: error_mode&.to_sym).render
       end
       assert_match(match, exception.message)
     end
 
-    def assert_syntax_error(template)
-      assert_match_syntax_error("", template)
+    def assert_syntax_error(template, error_mode: nil)
+      assert_match_syntax_error("", template, error_mode: error_mode)
     end
 
     def assert_usage_increment(name, times: 1)
@@ -75,6 +82,16 @@ module Minitest
       Environment.dangerously_override(environment, &blk)
     end
 
+    def with_error_modes(*modes)
+      old_mode = Liquid::Environment.default.error_mode
+      modes.each do |mode|
+        Liquid::Environment.default.error_mode = mode
+        yield
+      end
+    ensure
+      Liquid::Environment.default.error_mode = old_mode
+    end
+
     def with_custom_tag(tag_name, tag_class, &block)
       environment = Liquid::Environment.default.dup
       environment.register_tag(tag_name, tag_class)

test/unit/binary_expression_test.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class ExecutionSpy
-  attr_reader :called
-  attr_accessor :value
-
-  def initialize(value)
-    @called = false
-    @value = value
-  end
-
-  def to_liquid_value
-    @called = true
-    @value
-  end
-
-  def reset
-    @called = false
-  end
-end
-
-class BinaryExpressionTest < Minitest::Test
-  include Liquid
-
-  def test_simple_comparison_evaluation
-    assert_eval(false, BinaryExpression.new(5, ">", 5))
-    assert_eval(true, BinaryExpression.new(5, ">=", 5))
-    assert_eval(false, BinaryExpression.new(5, "<", 5))
-    assert_eval(true, BinaryExpression.new(5, "<=", 5))
-    assert_eval(true, BinaryExpression.new("abcd", "contains", "a"))
-  end
-
-  def test_logical_expression_short_circuiting
-    spy = ExecutionSpy.new(true)
-
-    # false or spy should try spy
-    assert_eval(true, BinaryExpression.new(false, 'or', spy))
-    assert_equal(true, spy.called)
-
-    spy.reset
-
-    # true or spy should not call spy
-    assert_eval(true, BinaryExpression.new(true, 'or', spy))
-    assert_equal(false, spy.called)
-
-    spy.reset
-
-    # true and spy should try spy
-    assert_eval(true, BinaryExpression.new(true, 'and', spy))
-    assert_equal(true, spy.called)
-
-    spy.reset
-
-    # false and spy should not try spy
-    assert_eval(false, BinaryExpression.new(false, 'and', spy))
-    assert_equal(false, spy.called)
-  end
-
-  def test_complex_evaluation
-    # 1 > 2 == 2 > 3
-    assert_eval(true, BinaryExpression.new(
-      BinaryExpression.new(1, '>', 2),
-      '==',
-      BinaryExpression.new(2, '>', 3),
-    ))
-
-    # 1 > 2 != 2 > 3
-    assert_eval(false, BinaryExpression.new(
-      BinaryExpression.new(1, '>', 2),
-      '!=',
-      BinaryExpression.new(2, '>', 3),
-    ))
-
-    # a > 0 == b.prop > 0
-    assert_eval(
-      true,
-      BinaryExpression.new(
-        BinaryExpression.new(var('a'), '>', 0),
-        '==',
-        BinaryExpression.new(var('b.prop'), '>', 0),
-      ),
-      { 'a' => 1, 'b' => { 'prop' => 2 } },
-    )
-  end
-
-  def test_method_literal_equality
-    empty = MethodLiteral.new(:empty?, '')
-
-    # a == empty, empty == a
-    assert_eval(false, BinaryExpression.new("123", "==", empty))
-    assert_eval(true, BinaryExpression.new("", "==", empty))
-    assert_eval(false, BinaryExpression.new(empty, "==", "123"))
-    assert_eval(true, BinaryExpression.new(empty, "==", ""))
-
-    # a does not have .empty?
-    assert_eval(nil, BinaryExpression.new(1, "==", empty))
-    assert_eval(nil, BinaryExpression.new(true, "==", empty))
-    assert_eval(nil, BinaryExpression.new(false, "==", empty))
-    assert_eval(nil, BinaryExpression.new(nil, "==", empty))
-
-    # a != empty
-    assert_eval(true, BinaryExpression.new("123", "!=", empty))
-    assert_eval(false, BinaryExpression.new("", "!=", empty))
-    assert_eval(true, BinaryExpression.new(empty, "!=", "123"))
-    assert_eval(false, BinaryExpression.new(empty, "!=", ""))
-
-    # a does not have .empty?
-    assert_eval(true, BinaryExpression.new(1, "!=", empty))
-    assert_eval(true, BinaryExpression.new(true, "!=", empty))
-    assert_eval(true, BinaryExpression.new(false, "!=", empty))
-    assert_eval(true, BinaryExpression.new(nil, "!=", empty))
-  end
-
-  def test_method_literal_comparison
-    empty = MethodLiteral.new(:empty?, '')
-
-    ['>', '>='].each do |op|
-      assert_eval(nil, BinaryExpression.new("123", op, empty))
-      assert_eval(nil, BinaryExpression.new("", op, empty))
-      assert_eval(nil, BinaryExpression.new(empty, op, "123"))
-      assert_eval(nil, BinaryExpression.new(empty, op, ""))
-    end
-
-    # Interesting case, contains on strings does include?(right.to_s)
-    assert_eval(true, BinaryExpression.new("123", "contains", empty))
-    assert_eval(true, BinaryExpression.new("", "contains", empty))
-  end
-
-  def assert_eval(expected, expr, assigns = {})
-    actual = expr.evaluate(context(assigns))
-    message = "Expected '#{expr}' to evaluate to '#{expected}'"
-    return assert_nil(actual, message) if expected.nil?
-
-    assert_equal(expected, actual, message)
-  end
-
-  def var(markup)
-    Parser.new(markup).variable_lookup
-  end
-
-  def context(assigns = {})
-    Context.build(outer_scope: assigns)
-  end
-end

test/unit/condition_unit_test.rb

@@ -9,6 +9,11 @@ class ConditionUnitTest < Minitest::Test
     @context = Liquid::Context.new
   end
 
+  def test_basic_condition
+    assert_equal(false, Condition.new(1, '==', 2).evaluate(Context.new))
+    assert_equal(true,  Condition.new(1, '==', 1).evaluate(Context.new))
+  end
+
   def test_default_operators_evalute_true
     assert_evaluates_true(1, '==', 1)
     assert_evaluates_true(1, '!=', 2)
@@ -67,17 +72,17 @@ class ConditionUnitTest < Minitest::Test
   end
 
   def test_hash_compare_backwards_compatibility
-    assert_evaluates_nil({}, '>', 2)
-    assert_evaluates_nil(2, '>', {})
-    assert_evaluates_false({}, '==', 2)
-    assert_evaluates_true({ 'a' => 1 }, '==', 'a' => 1)
-    assert_evaluates_true({ 'a' => 2 }, 'contains', 'a')
+    assert_nil(Condition.new({}, '>', 2).evaluate(Context.new))
+    assert_nil(Condition.new(2, '>', {}).evaluate(Context.new))
+    assert_equal(false, Condition.new({}, '==', 2).evaluate(Context.new))
+    assert_equal(true, Condition.new({ 'a' => 1 }, '==', 'a' => 1).evaluate(Context.new))
+    assert_equal(true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate(Context.new))
   end
 
   def test_contains_works_on_arrays
     @context          = Liquid::Context.new
     @context['array'] = [1, 2, 3, 4, 5]
-    array_expr        = VariableLookup.parse("array")
+    array_expr        = VariableLookup.new("array")
 
     assert_evaluates_false(array_expr, 'contains', 0)
     assert_evaluates_true(array_expr, 'contains', 1)
@@ -91,8 +96,8 @@ class ConditionUnitTest < Minitest::Test
 
   def test_contains_returns_false_for_nil_operands
     @context = Liquid::Context.new
-    assert_evaluates_false(VariableLookup.parse('not_assigned'), 'contains', '0')
-    assert_evaluates_false(0, 'contains', VariableLookup.parse('not_assigned'))
+    assert_evaluates_false(VariableLookup.new('not_assigned'), 'contains', '0')
+    assert_evaluates_false(0, 'contains', VariableLookup.new('not_assigned'))
   end
 
   def test_contains_return_false_on_wrong_data_type
@@ -105,64 +110,91 @@ class ConditionUnitTest < Minitest::Test
   end
 
   def test_or_condition
-    false_expr = '1 == 2'
-    true_expr = '1 == 1'
-
-    condition = Condition.new(expression(false_expr))
+    condition = Condition.new(1, '==', 2)
     assert_equal(false, condition.evaluate(Context.new))
 
-    condition = Condition.new(expression("#{false_expr} or #{false_expr}"))
+    condition.or(Condition.new(2, '==', 1))
+
     assert_equal(false, condition.evaluate(Context.new))
 
-    condition = Condition.new(expression("#{false_expr} or #{true_expr}"))
-    assert_equal(true, condition.evaluate(Context.new))
+    condition.or(Condition.new(1, '==', 1))
 
-    condition = Condition.new(expression("#{true_expr} or #{false_expr}"))
     assert_equal(true, condition.evaluate(Context.new))
   end
 
   def test_and_condition
-    false_expr = '1 == 2'
-    true_expr = '1 == 1'
+    condition = Condition.new(1, '==', 1)
 
-    condition = Condition.new(expression(true_expr))
     assert_equal(true, condition.evaluate(Context.new))
 
-    condition = Condition.new(expression("#{true_expr} and #{false_expr}"))
-    assert_equal(false, condition.evaluate(Context.new))
+    condition.and(Condition.new(2, '==', 2))
 
-    condition = Condition.new(expression("#{false_expr} and #{true_expr}"))
-    assert_equal(false, condition.evaluate(Context.new))
-
-    condition = Condition.new(expression("#{true_expr} and #{true_expr}"))
     assert_equal(true, condition.evaluate(Context.new))
+
+    condition.and(Condition.new(2, '==', 1))
+
+    assert_equal(false, condition.evaluate(Context.new))
+  end
+
+  def test_should_allow_custom_proc_operator
+    Condition.operators['starts_with'] = proc { |_cond, left, right| left =~ /^#{right}/ }
+
+    assert_evaluates_true('bob', 'starts_with', 'b')
+    assert_evaluates_false('bob', 'starts_with', 'o')
+  ensure
+    Condition.operators.delete('starts_with')
   end
 
   def test_left_or_right_may_contain_operators
     @context        = Liquid::Context.new
     @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
 
-    assert_evaluates_true(VariableLookup.parse("one"), '==', VariableLookup.parse("another"))
+    assert_evaluates_true(VariableLookup.new("one"), '==', VariableLookup.new("another"))
   end
 
-  def test_parse_expression
-    environment = Environment.build
+  def test_default_context_is_deprecated
+    if Gem::Version.new(Liquid::VERSION) >= Gem::Version.new('6.0.0')
+      flunk("Condition#evaluate without a context argument is to be removed")
+    end
+
+    _out, err = capture_io do
+      assert_equal(true, Condition.new(1, '==', 1).evaluate)
+    end
+
+    expected = "DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated " \
+      "and will be removed from Liquid 6.0.0."
+    assert_includes(err.lines.map(&:strip), expected)
+  end
+
+  def test_parse_expression_in_strict_mode
+    environment = Environment.build(error_mode: :strict)
     parse_context = ParseContext.new(environment: environment)
-    parser = parse_context.new_parser('product.title')
-    result = parser.expression
+    result = Condition.parse_expression(parse_context, 'product.title')
 
     assert_instance_of(VariableLookup, result)
     assert_equal('product', result.name)
     assert_equal(['title'], result.lookups)
   end
 
-  def test_parser_expression_returns_method_literal_for_blank_and_empty
-    environment = Environment.build
+  def test_parse_expression_in_strict2_mode_raises_internal_error
+    environment = Environment.build(error_mode: :strict2)
     parse_context = ParseContext.new(environment: environment)
-    parser = parse_context.new_parser('blank')
-    result = parser.expression
 
-    assert_instance_of(MethodLiteral, result)
+    error = assert_raises(Liquid::InternalError) do
+      Condition.parse_expression(parse_context, 'product.title')
+    end
+
+    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
+  end
+
+  def test_parse_expression_with_safe_true_in_strict2_mode
+    environment = Environment.build(error_mode: :strict2)
+    parse_context = ParseContext.new(environment: environment)
+    result = Condition.parse_expression(parse_context, 'product.title', safe: true)
+
+    assert_instance_of(VariableLookup, result)
+    assert_equal('product', result.name)
+    assert_equal(['title'], result.lookups)
   end
 
   # Tests for blank? comparison without ActiveSupport
@@ -182,99 +214,99 @@ class ConditionUnitTest < Minitest::Test
     # Template authors expect "   " to be blank since it has no visible content.
     # This matches ActiveSupport's String#blank? which returns true for whitespace-only strings.
     @context['whitespace'] = '   '
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_true(VariableLookup.parse('whitespace'), '==', blank_literal)
+    assert_evaluates_true(VariableLookup.new('whitespace'), '==', blank_literal)
   end
 
   def test_blank_with_empty_string
     # An empty string has no content, so it should be considered blank.
     # This is the most basic case of a blank string.
     @context['empty_string'] = ''
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_true(VariableLookup.parse('empty_string'), '==', blank_literal)
+    assert_evaluates_true(VariableLookup.new('empty_string'), '==', blank_literal)
   end
 
   def test_blank_with_empty_array
     # Empty arrays have no elements, so they are blank.
     # Useful for checking if a collection has items: {% if products == blank %}
     @context['empty_array'] = []
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_true(VariableLookup.parse('empty_array'), '==', blank_literal)
+    assert_evaluates_true(VariableLookup.new('empty_array'), '==', blank_literal)
   end
 
   def test_blank_with_empty_hash
     # Empty hashes have no key-value pairs, so they are blank.
     # Useful for checking if settings/options exist: {% if settings == blank %}
     @context['empty_hash'] = {}
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_true(VariableLookup.parse('empty_hash'), '==', blank_literal)
+    assert_evaluates_true(VariableLookup.new('empty_hash'), '==', blank_literal)
   end
 
   def test_blank_with_nil
     # nil represents "nothing" and is the canonical blank value.
     # Unassigned variables resolve to nil, so this enables: {% if missing_var == blank %}
     @context['nil_value'] = nil
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_true(VariableLookup.parse('nil_value'), '==', blank_literal)
+    assert_evaluates_true(VariableLookup.new('nil_value'), '==', blank_literal)
   end
 
   def test_blank_with_false
     # false is considered blank to match ActiveSupport semantics.
     # This allows {% if some_flag == blank %} to work when flag is false.
     @context['false_value'] = false
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_true(VariableLookup.parse('false_value'), '==', blank_literal)
+    assert_evaluates_true(VariableLookup.new('false_value'), '==', blank_literal)
   end
 
   def test_not_blank_with_true
     # true is a definite value, not blank.
     # Ensures {% if flag == blank %} works correctly for boolean flags.
     @context['true_value'] = true
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_false(VariableLookup.parse('true_value'), '==', blank_literal)
+    assert_evaluates_false(VariableLookup.new('true_value'), '==', blank_literal)
   end
 
   def test_not_blank_with_number
     # Numbers (including zero) are never blank - they represent actual values.
     # 0 is a valid quantity, not the absence of a value.
     @context['number'] = 42
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_false(VariableLookup.parse('number'), '==', blank_literal)
+    assert_evaluates_false(VariableLookup.new('number'), '==', blank_literal)
   end
 
   def test_not_blank_with_string_content
     # A string with actual content is not blank.
     # This is the expected behavior for most template string comparisons.
     @context['string'] = 'hello'
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_false(VariableLookup.parse('string'), '==', blank_literal)
+    assert_evaluates_false(VariableLookup.new('string'), '==', blank_literal)
   end
 
   def test_not_blank_with_non_empty_array
     # An array with elements has content, so it's not blank.
     # Enables patterns like {% unless products == blank %}Show products{% endunless %}
     @context['array'] = [1, 2, 3]
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_false(VariableLookup.parse('array'), '==', blank_literal)
+    assert_evaluates_false(VariableLookup.new('array'), '==', blank_literal)
   end
 
   def test_not_blank_with_non_empty_hash
     # A hash with key-value pairs has content, so it's not blank.
     # Useful for checking if configuration exists: {% if config != blank %}
     @context['hash'] = { 'a' => 1 }
-    blank_literal = Expression::LITERALS['blank']
+    blank_literal = Condition.class_variable_get(:@@method_literals)['blank']
 
-    assert_evaluates_false(VariableLookup.parse('hash'), '==', blank_literal)
+    assert_evaluates_false(VariableLookup.new('hash'), '==', blank_literal)
   end
 
   # Tests for empty? comparison without ActiveSupport
@@ -288,9 +320,9 @@ class ConditionUnitTest < Minitest::Test
     # An empty string ("") has length 0, so it's empty.
     # Different from blank - empty is a stricter check.
     @context['empty_string'] = ''
-    empty_literal = Expression::LITERALS['empty']
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
 
-    assert_evaluates_true(VariableLookup.parse('empty_string'), '==', empty_literal)
+    assert_evaluates_true(VariableLookup.new('empty_string'), '==', empty_literal)
   end
 
   def test_empty_with_whitespace_string_not_empty
@@ -298,27 +330,27 @@ class ConditionUnitTest < Minitest::Test
     # This is the key difference between empty and blank:
     # "   ".empty? => false, but "   ".blank? => true
     @context['whitespace'] = '   '
-    empty_literal = Expression::LITERALS['empty']
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
 
-    assert_evaluates_false(VariableLookup.parse('whitespace'), '==', empty_literal)
+    assert_evaluates_false(VariableLookup.new('whitespace'), '==', empty_literal)
   end
 
   def test_empty_with_empty_array
     # An array with no elements is empty.
     # [].empty? => true
     @context['empty_array'] = []
-    empty_literal = Expression::LITERALS['empty']
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
 
-    assert_evaluates_true(VariableLookup.parse('empty_array'), '==', empty_literal)
+    assert_evaluates_true(VariableLookup.new('empty_array'), '==', empty_literal)
   end
 
   def test_empty_with_empty_hash
     # A hash with no key-value pairs is empty.
     # {}.empty? => true
     @context['empty_hash'] = {}
-    empty_literal = Expression::LITERALS['empty']
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
 
-    assert_evaluates_true(VariableLookup.parse('empty_hash'), '==', empty_literal)
+    assert_evaluates_true(VariableLookup.new('empty_hash'), '==', empty_literal)
   end
 
   def test_nil_is_not_empty
@@ -326,45 +358,30 @@ class ConditionUnitTest < Minitest::Test
     # nil is not a collection, so it cannot be empty.
     # This differs from blank: nil IS blank, but nil is NOT empty.
     @context['nil_value'] = nil
-    empty_literal = Expression::LITERALS['empty']
+    empty_literal = Condition.class_variable_get(:@@method_literals)['empty']
 
-    assert_evaluates_false(VariableLookup.parse('nil_value'), '==', empty_literal)
+    assert_evaluates_false(VariableLookup.new('nil_value'), '==', empty_literal)
   end
 
   private
 
-  def assert_evaluates_nil(left, op, right)
-    expr = BinaryExpression.new(left, op, right)
-    assert_nil(
-      Condition.new(expr).evaluate(@context),
-      "Evaluated not nil: #{left.inspect} #{op} #{right.inspect}",
-    )
-  end
-
   def assert_evaluates_true(left, op, right)
-    expr = BinaryExpression.new(left, op, right)
     assert(
-      Condition.new(expr).evaluate(@context),
+      Condition.new(left, op, right).evaluate(@context),
       "Evaluated false: #{left.inspect} #{op} #{right.inspect}",
     )
   end
 
   def assert_evaluates_false(left, op, right)
-    expr = BinaryExpression.new(left, op, right)
     assert(
-      !Condition.new(expr).evaluate(@context),
+      !Condition.new(left, op, right).evaluate(@context),
       "Evaluated true: #{left.inspect} #{op} #{right.inspect}",
     )
   end
 
   def assert_evaluates_argument_error(left, op, right)
     assert_raises(Liquid::ArgumentError) do
-      expr = BinaryExpression.new(left, op, right)
-      Condition.new(expr).evaluate(@context)
+      Condition.new(left, op, right).evaluate(@context)
     end
   end
-
-  def expression(markup)
-    Parser.new(markup).expression
-  end
 end # ConditionTest

test/unit/lexer_unit_test.rb

@@ -26,17 +26,10 @@ class LexerUnitTest < Minitest::Test
     )
   end
 
-  def test_equality
-    assert_equal(
-      [[:equality, '=='], [:equality, '<>'], [:equality, '!='], [:end_of_string]],
-      tokenize('== <> != '),
-    )
-  end
-
   def test_comparison
     assert_equal(
-      [[:comparison, '>'], [:comparison, '>='], [:comparison, '<'], [:comparison, '<='], [:comparison, 'contains'], [:end_of_string]],
-      tokenize('> >= < <= contains'),
+      [[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]],
+      tokenize('== <> contains '),
     )
   end
 
@@ -88,7 +81,7 @@ class LexerUnitTest < Minitest::Test
 
   def test_whitespace
     assert_equal(
-      [[:id, 'five'], [:pipe, '|'], [:equality, '=='], [:end_of_string]],
+      [[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]],
       tokenize("five|\n\t =="),
     )
   end

test/unit/parse_context_unit_test.rb

@@ -5,56 +5,119 @@ require 'test_helper'
 class ParseContextUnitTest < Minitest::Test
   include Liquid
 
-  def test_parser_expression_with_variable_lookup
-    parser = parse_context.new_parser('product.title')
-    result = parser.expression
+  def test_safe_parse_expression_with_variable_lookup
+    parser_strict = strict_parse_context.new_parser('product.title')
+    result_strict = strict_parse_context.safe_parse_expression(parser_strict)
 
-    assert_instance_of(VariableLookup, result)
-    assert_equal('product', result.name)
-    assert_equal(['title'], result.lookups)
+    parser_strict2 = strict2_parse_context.new_parser('product.title')
+    result_strict2 = strict2_parse_context.safe_parse_expression(parser_strict2)
+
+    assert_instance_of(VariableLookup, result_strict)
+    assert_equal('product', result_strict.name)
+    assert_equal(['title'], result_strict.lookups)
+
+    assert_instance_of(VariableLookup, result_strict2)
+    assert_equal('product', result_strict2.name)
+    assert_equal(['title'], result_strict2.lookups)
   end
 
-  def test_parser_expression_raises_syntax_error_for_invalid_expression
-    parser = parse_context.new_parser('')
+  def test_safe_parse_expression_raises_syntax_error_for_invalid_expression
+    parser_strict = strict_parse_context.new_parser('')
+    parser_strict2 = strict2_parse_context.new_parser('')
 
-    error = assert_raises(Liquid::SyntaxError) do
-      parser.expression
+    error_strict = assert_raises(Liquid::SyntaxError) do
+      strict_parse_context.safe_parse_expression(parser_strict)
+    end
+    assert_match(/is not a valid expression/, error_strict.message)
+
+    error_strict2 = assert_raises(Liquid::SyntaxError) do
+      strict2_parse_context.safe_parse_expression(parser_strict2)
     end
 
-    assert_match(/is not a valid expression/, error.message)
+    assert_match(/is not a valid expression/, error_strict2.message)
   end
 
   def test_parse_expression_with_variable_lookup
-    result = parse_context.new_parser('product.title').expression
+    result_strict = strict_parse_context.parse_expression('product.title')
 
-    assert_instance_of(VariableLookup, result)
-    assert_equal('product', result.name)
-    assert_equal(['title'], result.lookups)
+    assert_instance_of(VariableLookup, result_strict)
+    assert_equal('product', result_strict.name)
+    assert_equal(['title'], result_strict.lookups)
+
+    error = assert_raises(Liquid::InternalError) do
+      strict2_parse_context.parse_expression('product.title')
+    end
+
+    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
   end
 
-  def test_parser_expression_advances_parser_pointer
-    parser = parse_context.new_parser('foo, bar')
+  def test_parse_expression_with_safe_true
+    result_strict = strict_parse_context.parse_expression('product.title', safe: true)
 
-    # parser.expression consumes "foo"
-    first_result = parser.expression
+    assert_instance_of(VariableLookup, result_strict)
+    assert_equal('product', result_strict.name)
+    assert_equal(['title'], result_strict.lookups)
+
+    result_strict2 = strict2_parse_context.parse_expression('product.title', safe: true)
+
+    assert_instance_of(VariableLookup, result_strict2)
+    assert_equal('product', result_strict2.name)
+    assert_equal(['title'], result_strict2.lookups)
+  end
+
+  def test_parse_expression_with_empty_string
+    result_strict = strict_parse_context.parse_expression('')
+    assert_nil(result_strict)
+
+    error = assert_raises(Liquid::InternalError) do
+      strict2_parse_context.parse_expression('')
+    end
+
+    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
+  end
+
+  def test_parse_expression_with_empty_string_and_safe_true
+    result_strict = strict_parse_context.parse_expression('', safe: true)
+    assert_nil(result_strict)
+
+    result_strict2 = strict2_parse_context.parse_expression('', safe: true)
+    assert_nil(result_strict2)
+  end
+
+  def test_safe_parse_expression_advances_parser_pointer
+    parser = strict2_parse_context.new_parser('foo, bar')
+
+    # safe_parse_expression consumes "foo"
+    first_result = strict2_parse_context.safe_parse_expression(parser)
     assert_instance_of(VariableLookup, first_result)
     assert_equal('foo', first_result.name)
 
     parser.consume(:comma)
 
-    # parser.expression consumes "bar"
-    second_result = parser.expression
+    # safe_parse_expression consumes "bar"
+    second_result = strict2_parse_context.safe_parse_expression(parser)
     assert_instance_of(VariableLookup, second_result)
     assert_equal('bar', second_result.name)
 
     parser.consume(:end_of_string)
   end
 
+  def test_parse_expression_with_whitespace_in_strict2_mode
+    result = strict2_parse_context.parse_expression('   ', safe: true)
+    assert_nil(result)
+  end
+
   private
 
-  def parse_context
-    @parse_context ||= ParseContext.new(
-      environment: Environment.build,
+  def strict_parse_context
+    @strict_parse_context ||= ParseContext.new(
+      environment: Environment.build(error_mode: :strict),
+    )
+  end
+
+  def strict2_parse_context
+    @strict2_parse_context ||= ParseContext.new(
+      environment: Environment.build(error_mode: :strict2),
     )
   end
 end

test/unit/parser_unit_test.rb

@@ -45,193 +45,40 @@ class ParserUnitTest < Minitest::Test
     assert_equal(false, p.look(:number, 1))
   end
 
-  def test_expression_string
+  def test_expressions
     p = new_parser("hi.there hi?[5].there? hi.there.bob")
-    assert_equal('hi.there', p.expression_string)
-    assert_equal('hi?[5].there?', p.expression_string)
-    assert_equal('hi.there.bob', p.expression_string)
+    assert_equal('hi.there', p.expression)
+    assert_equal('hi?[5].there?', p.expression)
+    assert_equal('hi.there.bob', p.expression)
 
     p = new_parser("567 6.0 'lol' \"wut\"")
-    assert_equal('567', p.expression_string)
-    assert_equal('6.0', p.expression_string)
-    assert_equal("'lol'", p.expression_string)
-    assert_equal('"wut"', p.expression_string)
-  end
-
-  def test_expression
-    p = new_parser("hi.there hi?[5].there? hi.there.bob")
-    v1 = p.expression
-    v2 = p.expression
-    v3 = p.expression
-    assert(v1.is_a?(VariableLookup) && v1.name == 'hi' && v1.lookups[0] == 'there')
-    assert(v2.is_a?(VariableLookup) && v2.name == 'hi?' && v2.lookups[0] == 5)
-    assert(v3.is_a?(VariableLookup) && v3.name == 'hi' && v3.lookups[0] == 'there')
-
-    p = new_parser("567 6.0 'lol' \"wut\" true false (0..5)")
-    assert_equal(567, p.expression)
-    assert_equal(6.0, p.expression)
-    assert_equal('lol', p.expression)
-    assert_equal('wut', p.expression)
-    assert_equal(true, p.expression)
-    assert_equal(false, p.expression)
-    assert_equal(0..5, p.expression)
-  end
-
-  def test_logical
-    p = new_parser("a and b")
-    expr = p.expression
-    assert(expr.is_a?(BinaryExpression))
-    assert_equal('and', expr.operator)
-    assert_equal('a', expr.left_node.name)
-    assert_equal('b', expr.right_node.name)
-
-    p = new_parser("a and b or c")
-    expr = p.expression
-    assert(expr.is_a?(BinaryExpression))
-    assert_equal('and', expr.operator)
-    assert_equal('a', expr.left_node.name)
-    assert_equal('or', expr.right_node.operator)
-    assert_equal('b', expr.right_node.left_node.name)
-    assert_equal('c', expr.right_node.right_node.name)
-
-    p = new_parser("a == b and c or d")
-    expr = p.expression
-    assert(expr.is_a?(BinaryExpression))
-    assert_equal('and', expr.operator)
-    assert_equal('==',  expr.left_node.operator)
-    assert_equal('a',   expr.left_node.left_node.name)
-    assert_equal('b',   expr.left_node.right_node.name)
-    assert_equal('or',  expr.right_node.operator)
-    assert_equal('c',   expr.right_node.left_node.name)
-    assert_equal('d',   expr.right_node.right_node.name)
-  end
-
-  def test_equality
-    p = new_parser("a == b")
-    expr = p.expression
-    assert(expr.is_a?(BinaryExpression))
-    assert_equal('==', expr.operator)
-    assert_equal('a', expr.left_node.name)
-    assert_equal('b', expr.right_node.name)
-
-    # BinaryExpression(==)
-    #   left_node: BinaryExpression(<)
-    #     left_node: 0
-    #     right_node: 5
-    #   right_node: BinaryExpression(>)
-    #     left_node: 6
-    #     right_node: 1
-    p = new_parser("0 < 5 == 6 > 1")
-    expr = p.expression
-    assert(expr.is_a?(BinaryExpression))
-    assert_equal('==', expr.operator)
-    assert_equal(0, expr.left_node.left_node)
-    assert_equal(5, expr.left_node.right_node)
-    assert_equal(6, expr.right_node.left_node)
-    assert_equal(1, expr.right_node.right_node)
-  end
-
-  def test_comparison
-    p = new_parser("a > b")
-    expr = p.expression
-    assert(expr.is_a?(BinaryExpression))
-    assert_equal('>', expr.operator)
-    assert(expr.left_node.is_a?(VariableLookup))
-    assert_equal('a', expr.left_node.name)
-    assert(expr.right_node.is_a?(VariableLookup))
-    assert_equal('b', expr.right_node.name)
-
-    # BinaryExpression(>=)
-    #   left_node: BinaryExpression(>)
-    #     left_node: 10
-    #     right_node: 5
-    #   right_node: 4
-    p = new_parser("10 > 5 >= 4")
-    expr = p.expression
-    assert(expr.is_a?(BinaryExpression))
-    assert_equal('>=', expr.operator)
-    assert_equal(10, expr.left_node.left_node)
-    assert_equal(5, expr.left_node.right_node)
-    assert_equal(4, expr.right_node)
-  end
-
-  def test_number
-    p = new_parser('-1 0 1 2.0')
-    assert_equal(-1, p.number)
-    assert_equal(0, p.number)
-    assert_equal(1, p.number)
-    assert_equal(2.0, p.number)
-  end
-
-  def test_string
-    p = new_parser("'s1' \"s2\" 'this \"s3\"' \"that 's4'\"")
-    assert_equal('s1', p.string)
-    assert_equal('s2', p.string)
-    assert_equal('this "s3"', p.string)
-    assert_equal("that 's4'", p.string)
-  end
-
-  def test_unnamed_variable_lookup
-    p = new_parser('[key].title')
-    v = p.expression
-    assert(v.is_a?(VariableLookup))
-    assert(v.name.is_a?(VariableLookup))
-    assert_equal('key', v.name.name)
-    assert_equal('title', v.lookups[0])
-  end
-
-  def test_range_lookup
-    p = new_parser('(0..5) (a..b)')
-    assert_equal(0..5, p.expression)
-
-    r2 = p.expression
-    assert(r2.is_a?(RangeLookup))
-    assert_equal(1..4, r2.evaluate(Context.new({ 'a' => 1, 'b' => 4 })))
+    assert_equal('567', p.expression)
+    assert_equal('6.0', p.expression)
+    assert_equal("'lol'", p.expression)
+    assert_equal('"wut"', p.expression)
   end
 
   def test_ranges
     p = new_parser("(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)")
-    assert_equal('(5..7)', p.expression_string)
-    assert_equal('(1.5..9.6)', p.expression_string)
-    assert_equal('(young..old)', p.expression_string)
-    assert_equal('(hi[5].wat..old)', p.expression_string)
+    assert_equal('(5..7)', p.expression)
+    assert_equal('(1.5..9.6)', p.expression)
+    assert_equal('(young..old)', p.expression)
+    assert_equal('(hi[5].wat..old)', p.expression)
   end
 
-  def test_groupings_aka_parenthesized_expressions
-    # without the parens, this would be evaled as a and (b or c)
-    p = new_parser("(a and b) or c")
-    expr = p.expression
-    assert_equal('or', expr.operator)
-    assert_equal('and', expr.left_node.operator)
-    assert_equal('a', expr.left_node.left_node.name)
-    assert_equal('b', expr.left_node.right_node.name)
-    assert_equal('c', expr.right_node.name)
-  end
-
-  def test_groupings_can_be_used_to_hijack_operation_priority
-    # without parens would be parsed as `a and (b == c)`
-    p = new_parser("(a and b) == c")
-    expr = p.expression
-    assert_equal('==', expr.operator)
-    assert_equal('and', expr.left_node.operator)
-    assert_equal('a', expr.left_node.left_node.name)
-    assert_equal('b', expr.left_node.right_node.name)
-    assert_equal('c', expr.right_node.name)
-  end
-
-  def test_argument_string
+  def test_arguments
     p = new_parser("filter: hi.there[5], keyarg: 7")
     assert_equal('filter', p.consume(:id))
     assert_equal(':', p.consume(:colon))
-    assert_equal('hi.there[5]', p.argument_string)
+    assert_equal('hi.there[5]', p.argument)
     assert_equal(',', p.consume(:comma))
-    assert_equal('keyarg: 7', p.argument_string)
+    assert_equal('keyarg: 7', p.argument)
   end
 
   def test_invalid_expression
     assert_raises(SyntaxError) do
       p = new_parser("==")
-      p.expression_string
+      p.expression
     end
   end
 

test/unit/partial_cache_unit_test.rb

@@ -175,7 +175,7 @@ class PartialCacheUnitTest < Minitest::Test
     assert_equal('some/path/my_partial', partial.name)
   end
 
-  def test_cache_key
+  def test_includes_error_mode_into_template_cache
     template_factory = StubTemplateFactory.new
     context = Liquid::Context.build(
       registers: {
@@ -184,14 +184,16 @@ class PartialCacheUnitTest < Minitest::Test
       },
     )
 
-    Liquid::PartialCache.load(
-      'my_partial',
-      context: context,
-      parse_context: Liquid::ParseContext.new,
-    )
+    [:lax, :warn, :strict, :strict2].each do |error_mode|
+      Liquid::PartialCache.load(
+        'my_partial',
+        context: context,
+        parse_context: Liquid::ParseContext.new(error_mode: error_mode),
+      )
+    end
 
     assert_equal(
-      ["my_partial"],
+      ["my_partial:lax", "my_partial:warn", "my_partial:strict", "my_partial:strict2"],
       context.registers[:cached_partials].keys,
     )
   end

test/unit/resource_limits_unit_test.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ResourceLimitsUnitTest < Minitest::Test
+  def test_cumulative_scores_initialize_to_zero
+    limits = Liquid::ResourceLimits.new({})
+    assert_equal(0, limits.cumulative_render_score)
+    assert_equal(0, limits.cumulative_assign_score)
+  end
+
+  def test_cumulative_limits_default_to_nil
+    limits = Liquid::ResourceLimits.new({})
+    assert_nil(limits.cumulative_render_score_limit)
+    assert_nil(limits.cumulative_assign_score_limit)
+  end
+
+  def test_cumulative_limits_configurable_via_hash
+    limits = Liquid::ResourceLimits.new(
+      cumulative_render_score_limit: 500,
+      cumulative_assign_score_limit: 300,
+    )
+    assert_equal(500, limits.cumulative_render_score_limit)
+    assert_equal(300, limits.cumulative_assign_score_limit)
+  end
+
+  def test_cumulative_limits_configurable_via_accessor
+    limits = Liquid::ResourceLimits.new({})
+    limits.cumulative_render_score_limit = 500
+    assert_equal(500, limits.cumulative_render_score_limit)
+  end
+
+  def test_cumulative_scores_survive_reset
+    limits = Liquid::ResourceLimits.new({})
+    limits.increment_render_score(10)
+    limits.increment_assign_score(5)
+
+    limits.reset
+
+    assert_equal(0, limits.render_score)
+    assert_equal(0, limits.assign_score)
+    assert_equal(10, limits.cumulative_render_score)
+    assert_equal(5, limits.cumulative_assign_score)
+  end
+
+  def test_cumulative_scores_accumulate_across_resets
+    limits = Liquid::ResourceLimits.new({})
+    limits.increment_render_score(10)
+    limits.reset
+    limits.increment_render_score(20)
+    limits.reset
+    limits.increment_render_score(30)
+
+    assert_equal(30, limits.render_score)
+    assert_equal(60, limits.cumulative_render_score)
+  end
+
+  def test_cumulative_render_score_limit_raises
+    limits = Liquid::ResourceLimits.new(cumulative_render_score_limit: 25)
+    limits.increment_render_score(10)
+    limits.reset
+    limits.increment_render_score(10)
+    limits.reset
+
+    assert_raises(Liquid::MemoryError) do
+      limits.increment_render_score(10)
+    end
+    assert(limits.reached?)
+  end
+
+  def test_cumulative_assign_score_limit_raises
+    limits = Liquid::ResourceLimits.new(cumulative_assign_score_limit: 15)
+    limits.increment_assign_score(8)
+    limits.reset
+
+    assert_raises(Liquid::MemoryError) do
+      limits.increment_assign_score(8)
+    end
+    assert(limits.reached?)
+  end
+
+  def test_per_template_limits_still_work_with_cumulative
+    limits = Liquid::ResourceLimits.new(
+      render_score_limit: 50,
+      cumulative_render_score_limit: 1000,
+    )
+    assert_raises(Liquid::MemoryError) do
+      limits.increment_render_score(51)
+    end
+  end
+end

test/unit/tags/case_tag_unit_test.rb

@@ -20,9 +20,15 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    with_error_modes(:lax, :strict) do
+      assert_template_result("one", template)
+    end
 
-    assert_match(/Expected end_of_string but found/, error.message)
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+
+      assert_match(/Expected end_of_string but found/, error.message)
+    end
   end
 
   def test_case_when_with_trailing_element
@@ -35,9 +41,15 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+    with_error_modes(:lax, :strict) do
+      assert_template_result("one", template)
+    end
 
-    assert_match(/Expected end_of_string but found/, error.message)
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+
+      assert_match(/Expected end_of_string but found/, error.message)
+    end
   end
 
   def test_case_when_with_comma
@@ -50,7 +62,9 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    assert_template_result("one", template)
+    with_error_modes(:lax, :strict, :strict2) do
+      assert_template_result("one", template)
+    end
   end
 
   def test_case_when_with_or
@@ -63,7 +77,9 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    assert_template_result("one", template)
+    with_error_modes(:lax, :strict, :strict2) do
+      assert_template_result("one", template)
+    end
   end
 
   def test_case_when_empty
@@ -76,12 +92,14 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    assert_template_result("2 or empty", template, { 'x' => 2 })
-    assert_template_result("2 or empty", template, { 'x' => {} })
-    assert_template_result("2 or empty", template, { 'x' => [] })
-    assert_template_result("not 2 or empty", template, { 'x' => { 'a' => 'b' } })
-    assert_template_result("not 2 or empty", template, { 'x' => ['a'] })
-    assert_template_result("not 2 or empty", template, { 'x' => 4 })
+    with_error_modes(:lax, :strict, :strict2) do
+      assert_template_result("2 or empty", template, { 'x' => 2 })
+      assert_template_result("2 or empty", template, { 'x' => {} })
+      assert_template_result("2 or empty", template, { 'x' => [] })
+      assert_template_result("not 2 or empty", template, { 'x' => { 'a' => 'b' } })
+      assert_template_result("not 2 or empty", template, { 'x' => ['a'] })
+      assert_template_result("not 2 or empty", template, { 'x' => 4 })
+    end
   end
 
   def test_case_with_invalid_expression
@@ -95,9 +113,15 @@ class CaseTagUnitTest < Minitest::Test
     LIQUID
     assigns = { 'foo' => { 'bar' => 'baz' } }
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template, assigns) }
+    with_error_modes(:lax, :strict) do
+      assert_template_result("one", template, assigns)
+    end
 
-    assert_match(/Unexpected character =/, error.message)
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 
   def test_case_when_with_invalid_expression
@@ -111,8 +135,14 @@ class CaseTagUnitTest < Minitest::Test
     LIQUID
     assigns = { 'foo' => { 'bar' => 'baz' } }
 
-    error = assert_raises(Liquid::SyntaxError) { Template.parse(template, assigns) }
+    with_error_modes(:lax, :strict) do
+      assert_template_result("one", template, assigns)
+    end
 
-    assert_match(/Unexpected character =/, error.message)
+    with_error_modes(:strict2) do
+      error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
+
+      assert_match(/Unexpected character =/, error.message)
+    end
   end
 end

test/unit/variable_unit_test.rb

@@ -7,20 +7,20 @@ class VariableUnitTest < Minitest::Test
 
   def test_variable
     var = create_variable('hello')
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
   end
 
   def test_filters
     var = create_variable('hello | textileze')
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['textileze', []]], var.filters)
 
     var = create_variable('hello | textileze | paragraph')
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable(%( hello | strftime: '%Y'))
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['strftime', ['%Y']]], var.filters)
 
     var = create_variable(%( 'typo' | link_to: 'Typo', true ))
@@ -44,11 +44,11 @@ class VariableUnitTest < Minitest::Test
     assert_equal([['repeat', [3, 3, 3]]], var.filters)
 
     var = create_variable(%( hello | strftime: '%Y, okay?'))
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['strftime', ['%Y, okay?']]], var.filters)
 
     var = create_variable(%( hello | things: "%Y, okay?", 'the other one'))
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['things', ['%Y, okay?', 'the other one']]], var.filters)
   end
 
@@ -60,18 +60,24 @@ class VariableUnitTest < Minitest::Test
 
   def test_filters_without_whitespace
     var = create_variable('hello | textileze | paragraph')
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable('hello|textileze|paragraph')
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable("hello|replace:'foo','bar'|textileze")
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['replace', ['foo', 'bar']], ['textileze', []]], var.filters)
   end
 
+  def test_symbol
+    var = create_variable("http://disney.com/logo.gif | image: 'med' ", error_mode: :lax)
+    assert_equal(VariableLookup.new('http://disney.com/logo.gif'), var.name)
+    assert_equal([['image', ['med']]], var.filters)
+  end
+
   def test_string_to_filter
     var = create_variable("'http://disney.com/logo.gif' | image: 'med' ")
     assert_equal('http://disney.com/logo.gif', var.name)
@@ -99,12 +105,14 @@ class VariableUnitTest < Minitest::Test
   end
 
   def test_dashes
-    assert_equal(VariableLookup.parse('foo-bar'), create_variable('foo-bar').name)
-    assert_equal(VariableLookup.parse('foo-bar-2'), create_variable('foo-bar-2').name)
+    assert_equal(VariableLookup.new('foo-bar'), create_variable('foo-bar').name)
+    assert_equal(VariableLookup.new('foo-bar-2'), create_variable('foo-bar-2').name)
 
-    assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
-    assert_raises(Liquid::SyntaxError) { create_variable('-foo') }
-    assert_raises(Liquid::SyntaxError) { create_variable('2foo') }
+    with_error_modes(:strict) do
+      assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
+      assert_raises(Liquid::SyntaxError) { create_variable('-foo') }
+      assert_raises(Liquid::SyntaxError) { create_variable('2foo') }
+    end
   end
 
   def test_string_with_special_chars
@@ -114,47 +122,79 @@ class VariableUnitTest < Minitest::Test
 
   def test_string_dot
     var = create_variable(%( test.test ))
-    assert_equal(VariableLookup.parse('test.test'), var.name)
+    assert_equal(VariableLookup.new('test.test'), var.name)
   end
 
   def test_filter_with_keyword_arguments
     var = create_variable(%( hello | things: greeting: "world", farewell: 'goodbye'))
-    assert_equal(VariableLookup.parse('hello'), var.name)
+    assert_equal(VariableLookup.new('hello'), var.name)
     assert_equal([['things', [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters)
   end
 
-  def test_filter_argument_parsing
-    # optional colon
-    var = create_variable(%(n | f1 | f2:))
-    assert_equal([['f1', []], ['f2', []]], var.filters)
+  def test_lax_filter_argument_parsing
+    var = create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ), error_mode: :lax)
+    assert_equal(VariableLookup.new('number_of_comments'), var.name)
+    assert_equal([['pluralize', ['comment', 'comments']]], var.filters)
 
-    # missing argument throws error
-    assert_raises(SyntaxError) { create_variable(%(n | f1: ,)) }
-    assert_raises(SyntaxError) { create_variable(%(n | f1: ,| f2)) }
+    # missing does not throws error
+    create_variable(%(n | f1: ,), error_mode: :lax)
+    create_variable(%(n | f1: ,| f2), error_mode: :lax)
 
-    # arg requires colon
-    assert_raises(SyntaxError) { create_variable(%(n | f1 1)) }
-
-    # trailing comma doesn't throw
-    create_variable(%(n | f1: 1, 2, 3, | f2:))
-
-    # missing comma throws error
-    assert_raises(SyntaxError) { create_variable(%(n | filter: 1 2, 3)) }
+    # arg does not require colon, but ignores args :O, also ignores first kwarg since it splits on ':'
+    var = create_variable(%(n | f1 1 | f2 k1: v1), error_mode: :lax)
+    assert_equal([['f1', []], ['f2', [VariableLookup.new('v1')]]], var.filters)
 
     # positional and kwargs parsing
-    var = create_variable(%(n | filter: 1, 2, 3 | filter2: k1: 1, k2: 2))
+    var = create_variable(%(n | filter: 1, 2, 3 | filter2: k1: 1, k2: 2), error_mode: :lax)
     assert_equal([['filter', [1, 2, 3]], ['filter2', [], { "k1" => 1, "k2" => 2 }]], var.filters)
 
-    # positional and kwargs mixed
-    var = create_variable(%(n | filter: 'a', 'b', key1: 1, key2: 2, 'c'))
-    assert_equal([["filter", ["a", "b", "c"], { "key1" => 1, "key2" => 2 }]], var.filters)
-
     # positional and kwargs intermixed (pos1, key1: val1, pos2)
-    var = create_variable(%(n | link_to: class: "black", "https://example.com", title: "title"))
+    var = create_variable(%(n | link_to: class: "black", "https://example.com", title: "title"), error_mode: :lax)
     assert_equal([['link_to', ["https://example.com"], { "class" => "black", "title" => "title" }]], var.filters)
+  end
 
-    # string key throws
-    assert_raises(SyntaxError) { create_variable(%(n | pluralize: 'comment': 'comments')) }
+  def test_strict_filter_argument_parsing
+    with_error_modes(:strict) do
+      assert_raises(SyntaxError) do
+        create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ))
+      end
+    end
+  end
+
+  def test_strict2_filter_argument_parsing
+    with_error_modes(:strict2) do
+      # optional colon
+      var = create_variable(%(n | f1 | f2:))
+      assert_equal([['f1', []], ['f2', []]], var.filters)
+
+      # missing argument throws error
+      assert_raises(SyntaxError) { create_variable(%(n | f1: ,)) }
+      assert_raises(SyntaxError) { create_variable(%(n | f1: ,| f2)) }
+
+      # arg requires colon
+      assert_raises(SyntaxError) { create_variable(%(n | f1 1)) }
+
+      # trailing comma doesn't throw
+      create_variable(%(n | f1: 1, 2, 3, | f2:))
+
+      # missing comma throws error
+      assert_raises(SyntaxError) { create_variable(%(n | filter: 1 2, 3)) }
+
+      # positional and kwargs parsing
+      var = create_variable(%(n | filter: 1, 2, 3 | filter2: k1: 1, k2: 2))
+      assert_equal([['filter', [1, 2, 3]], ['filter2', [], { "k1" => 1, "k2" => 2 }]], var.filters)
+
+      # positional and kwargs mixed
+      var = create_variable(%(n | filter: 'a', 'b', key1: 1, key2: 2, 'c'))
+      assert_equal([["filter", ["a", "b", "c"], { "key1" => 1, "key2" => 2 }]], var.filters)
+
+      # positional and kwargs intermixed (pos1, key1: val1, pos2)
+      var = create_variable(%(n | link_to: class: "black", "https://example.com", title: "title"))
+      assert_equal([['link_to', ["https://example.com"], { "class" => "black", "title" => "title" }]], var.filters)
+
+      # string key throws
+      assert_raises(SyntaxError) { create_variable(%(n | pluralize: 'comment': 'comments')) }
+    end
   end
 
   def test_output_raw_source_of_variable
@@ -163,7 +203,7 @@ class VariableUnitTest < Minitest::Test
   end
 
   def test_variable_lookup_interface
-    lookup = VariableLookup.parse('a.b.c')
+    lookup = VariableLookup.new('a.b.c')
     assert_equal('a', lookup.name)
     assert_equal(['b', 'c'], lookup.lookups)
   end