Fixup GH action

(No anonymous classes)

.github/workflows/liquid.yml

@@ -22,17 +22,17 @@ jobs:
               rubyopt: "--enable-frozen-string-literal",
             }
           - { ruby: 3.4, allowed-failure: false, rubyopt: "--yjit" }
-          - { ruby: ruby-head, allowed-failure: false }
+          - { ruby: head, allowed-failure: false }
           - {
-              ruby: ruby-head,
+              ruby: head,
               allowed-failure: false,
               rubyopt: "--enable-frozen-string-literal",
             }
-          - { ruby: ruby-head, allowed-failure: false, rubyopt: "--yjit" }
+          - { ruby: head, allowed-failure: false, rubyopt: "--yjit" }
     name: Test Ruby ${{ matrix.entry.ruby }}
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@dffc446db9ba5a0c4446edb5bca1c5c473a806c5 # v1.235.0
+      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
         with:
           ruby-version: ${{ matrix.entry.ruby }}
           bundler-cache: true
@@ -46,7 +46,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@f43a0e5ff2bd294095638e18286ca9a3d1956744 # v3.6.0
-      - uses: ruby/setup-ruby@dffc446db9ba5a0c4446edb5bca1c5c473a806c5 # v1.235.0
+      - uses: ruby/setup-ruby@a25f1e45f0e65a92fcb1e95e8847f78fb0a7197a # v1.273.0
         with:
           bundler-cache: true
       - run: bundle exec rake memory_profile:run

History.md

@@ -1,5 +1,12 @@
 # Liquid Change Log
 
+## 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]
+
+## 5.10.0
+* Introduce support for Inline Snippets [Julia Boutin]
+
 ## 5.9.0
 * Introduce `:rigid` error mode for stricter, safer parsing of all tags [CP Clermont, Guilherme Carreiro]
 

README.md

@@ -103,10 +103,10 @@ Liquid also comes with different parsers that can be used when editing templates
 when templates are invalid. You can enable this new parser like this:
 
 ```ruby
-Liquid::Environment.default.error_mode = :rigid  # 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.
+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`:

Rakefile

@@ -33,7 +33,7 @@ task :rubocop do
   end
 end
 
-desc('runs test suite with lax, strict, and rigid parsers')
+desc('runs test suite with lax, strict, and strict2 parsers')
 task :test do
   ENV['LIQUID_PARSER_MODE'] = 'lax'
   Rake::Task['base_test'].invoke
@@ -42,7 +42,7 @@ task :test do
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
-  ENV['LIQUID_PARSER_MODE'] = 'rigid'
+  ENV['LIQUID_PARSER_MODE'] = 'strict2'
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
@@ -55,7 +55,7 @@ task :test do
     Rake::Task['integration_test'].reenable
     Rake::Task['integration_test'].invoke
 
-    ENV['LIQUID_PARSER_MODE'] = 'rigid'
+    ENV['LIQUID_PARSER_MODE'] = 'strict2'
     Rake::Task['integration_test'].reenable
     Rake::Task['integration_test'].invoke
   end
@@ -88,13 +88,13 @@ namespace :benchmark do
     ruby "./performance/benchmark.rb strict"
   end
 
-  desc "Run the liquid benchmark with rigid parsing"
-  task :rigid do
-    ruby "./performance/benchmark.rb rigid"
+  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 rigid parsing"
-  task run: [:lax, :strict, :rigid]
+  desc "Run the liquid benchmark with lax, strict, and strict2 parsing"
+  task run: [:lax, :strict, :strict2]
 
   desc "Run unit benchmarks"
   namespace :unit do

bin/render

@@ -41,6 +41,6 @@ def assigns
 end
 
 puts Liquid::Template
-  .parse(source, error_mode: :rigid)
+  .parse(source, error_mode: :strict2)
   .tap { |t| t.registers[:file_system] = VirtualFileSystem.new }
   .render(assigns)

lib/liquid/context.rb

@@ -184,7 +184,7 @@ module Liquid
     end
 
     def key?(key)
-      self[key] != nil
+      find_variable(key, raise_on_not_found: false) != nil
     end
 
     def evaluate(object)

lib/liquid/environment.rb

@@ -34,7 +34,7 @@ module Liquid
       # @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 :rigid, :strict, :warn, or :lax).
+      #  (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.

lib/liquid/parse_context.rb

@@ -55,15 +55,15 @@ module Liquid
     end
 
     def parse_expression(markup, safe: false)
-      if !safe && @error_mode == :rigid
+      if !safe && @error_mode == :strict2
         # parse_expression is a widely used API. To maintain backward
-        # compatibility while raising awareness about rigid parser standards,
+        # compatibility while raising awareness about strict2 parser standards,
         # the safe flag supports API users make a deliberate decision.
         #
-        # In rigid mode, markup MUST come from a string returned by the parser
+        # 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 rigid mode"
+        raise Liquid::InternalError, "unsafe parse_expression cannot be used in strict2 mode"
       end
 
       Expression.parse(markup, @string_scanner, @expression_cache)

lib/liquid/parser_switching.rb

@@ -7,16 +7,19 @@ module Liquid
     # 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 rigid mode where it uses the rigid parser.
+    # 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 rigid_parse_with_error_context(markup) if rigid_mode?
+      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
@@ -28,12 +31,13 @@ module Liquid
 
     def parse_with_selected_parser(markup)
       case parse_context.error_mode
-      when :rigid  then rigid_parse_with_error_context(markup)
-      when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
+      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
-          rigid_parse_with_error_context(markup)
+          strict2_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
           lax_parse(markup)
@@ -41,14 +45,18 @@ module Liquid
       end
     end
 
-    def rigid_mode?
-      parse_context.error_mode == :rigid
+    def strict2_mode?
+      parse_context.error_mode == :strict2 || parse_context.error_mode == :rigid
     end
 
     private
 
-    def rigid_parse_with_error_context(markup)
-      rigid_parse(markup)
+    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)

lib/liquid/tags/case.rb

@@ -86,7 +86,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       parser = @parse_context.new_parser(markup)
       @left = safe_parse_expression(parser)
       parser.consume(:end_of_string)
@@ -107,18 +107,18 @@ module Liquid
     def record_when_condition(markup)
       body = new_body
 
-      if rigid_mode?
-        parse_rigid_when(markup, body)
+      if strict2_mode?
+        parse_strict2_when(markup, body)
       else
         parse_lax_when(markup, body)
       end
     end
 
-    def parse_rigid_when(markup, body)
+    def parse_strict2_when(markup, body)
       parser = @parse_context.new_parser(markup)
 
       loop do
-        expr = safe_parse_expression(parser)
+        expr = Condition.parse_expression(parse_context, parser.expression, safe: true)
         block = Condition.new(@left, '==', expr)
         block.attach(body)
         @blocks << block

lib/liquid/tags/cycle.rb

@@ -56,7 +56,7 @@ module Liquid
     private
 
     # cycle [name:] expression(, expression)*
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @variables = []

lib/liquid/tags/for.rb

@@ -111,7 +111,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       strict_parse(markup)
     end
 

lib/liquid/tags/if.rb

@@ -66,7 +66,7 @@ module Liquid
 
     private
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       strict_parse(markup)
     end
 

lib/liquid/tags/include.rb

@@ -84,7 +84,7 @@ module Liquid
     alias_method :parse_context, :options
     private :parse_context
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @template_name_expr = safe_parse_expression(p)

lib/liquid/tags/render.rb

@@ -85,10 +85,10 @@ module Liquid
     end
 
     # render (string) (with|for expression)? (as id)? (key: value)*
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
-      @template_name_expr = parse_expression(rigid_template_name(p), safe: true)
+      @template_name_expr = parse_expression(strict2_template_name(p), safe: true)
       with_or_for         = p.id?("for") || p.id?("with")
       @variable_name_expr = safe_parse_expression(p) if with_or_for
       @alias_name         = p.consume(:id) if p.id?("as")
@@ -107,7 +107,7 @@ module Liquid
       p.consume(:end_of_string)
     end
 
-    def rigid_template_name(p)
+    def strict2_template_name(p)
       p.consume(:string)
     end
 

lib/liquid/tags/table_row.rb

@@ -34,7 +34,7 @@ module Liquid
       parse_with_selected_parser(markup)
     end
 
-    def rigid_parse(markup)
+    def strict2_parse(markup)
       p = @parse_context.new_parser(markup)
 
       @variable_name = p.consume(:id)

lib/liquid/template.rb

@@ -25,7 +25,7 @@ module Liquid
       # :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
-      # :rigid enforces correct syntax for all 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

lib/liquid/utils.rb

@@ -95,6 +95,8 @@ module Liquid
 
     def self.to_s(obj, seen = {})
       case obj
+      when BigDecimal
+        obj.to_s("F")
       when Hash
         # If the custom hash implementation overrides `#to_s`, use their
         # custom implementation. Otherwise we use Liquid's default

lib/liquid/variable.rb

@@ -74,14 +74,14 @@ module Liquid
       p.consume(:end_of_string)
     end
 
-    def rigid_parse(markup)
+    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 << rigid_parse_filter_expressions(p) while p.consume?(:pipe)
+      @filters << strict2_parse_filter_expressions(p) while p.consume?(:pipe)
       p.consume(:end_of_string)
     end
 
@@ -156,7 +156,7 @@ module Liquid
     # argument = (positional_argument | keyword_argument)
     # positional_argument = expression
     # keyword_argument = id ":" expression
-    def rigid_parse_filter_expressions(p)
+    def strict2_parse_filter_expressions(p)
       filtername = p.consume(:id)
       filter_args = []
       keyword_args = {}

lib/liquid/version.rb

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

test/integration/context_test.rb

@@ -639,6 +639,21 @@ class ContextTest < Minitest::Test
     end
   end
 
+  def test_key_lookup_will_raise_for_missing_keys_when_strict_variables_is_enabled
+    context = Context.new
+    context.strict_variables = true
+    assert_raises(Liquid::UndefinedVariable) do
+      context['unknown']
+    end
+  end
+
+  def test_has_key_will_not_raise_for_missing_keys_when_strict_variables_is_enabled
+    context = Context.new
+    context.strict_variables = true
+    refute(context.key?('unknown'))
+    assert_empty(context.errors)
+  end
+
   def test_context_always_uses_static_registers
     registers = {
       my_register: :my_value,

test/integration/hash_rendering_test.rb

@@ -88,17 +88,11 @@ class HashRenderingTest < Minitest::Test
   end
 
   def test_rendering_hash_with_custom_to_s_method_uses_custom_to_s
-    my_hash = Class.new(Hash) do
-      def to_s
-        "kewl"
-      end
-    end.new
-
-    assert_template_result("kewl", "{{ my_hash }}", { "my_hash" => my_hash })
+    assert_template_result("kewl", "{{ my_hash }}", { "my_hash" => HashWithCustomToS.new })
   end
 
   def test_rendering_hash_without_custom_to_s_uses_default_inspect
-    my_hash = Class.new(Hash).new
+    my_hash = HashWithoutCustomToS.new
     my_hash[:foo] = :bar
 
     assert_template_result("{:foo=>:bar}", "{{ my_hash }}", { "my_hash" => my_hash })

test/integration/standard_filter_test.rb

@@ -294,13 +294,7 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_join_calls_to_liquid_on_each_element
-    drop = Class.new(Liquid::Drop) do
-      def to_liquid
-        'i did it'
-      end
-    end
-
-    assert_equal('i did it, i did it', @filters.join([drop.new, drop.new], ", "))
+    assert_equal('i did it, i did it', @filters.join([CustomToLiquidDrop.new('i did it'), CustomToLiquidDrop.new('i did it')], ", "))
   end
 
   def test_sort

test/integration/tags/cycle_tag_test.rb

@@ -101,7 +101,7 @@ class CycleTagTest < Minitest::Test
       assert_template_result("a", template2)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
       error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
 
@@ -129,7 +129,7 @@ class CycleTagTest < Minitest::Test
       assert_template_result("N", template5)
     end
 
-    with_error_modes(:rigid) do
+    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) }
@@ -157,7 +157,7 @@ class CycleTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -174,7 +174,7 @@ class CycleTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/include_tag_test.rb

@@ -204,7 +204,7 @@ class IncludeTagTest < Minitest::Test
     )
   end
 
-  def test_rigid_parsing_errors
+  def test_strict2_parsing_errors
     with_error_modes(:lax, :strict) do
       assert_template_result(
         'hello value1 value2',
@@ -213,7 +213,7 @@ class IncludeTagTest < Minitest::Test
       )
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_syntax_error(
         '{% include "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
       )
@@ -408,7 +408,7 @@ class IncludeTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -421,7 +421,7 @@ class IncludeTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -434,7 +434,7 @@ class IncludeTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/render_tag_test.rb

@@ -105,7 +105,7 @@ class RenderTagTest < Minitest::Test
     assert_syntax_error("{% assign name = 'snippet' %}{% render name %}")
   end
 
-  def test_rigid_parsing_errors
+  def test_strict2_parsing_errors
     with_error_modes(:lax, :strict) do
       assert_template_result(
         'hello value1 value2',
@@ -114,7 +114,7 @@ class RenderTagTest < Minitest::Test
       )
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_syntax_error(
         '{% render "snippet" !!! arg1: "value1" ~~~ arg2: "value2" %}',
       )
@@ -322,7 +322,7 @@ class RenderTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end
@@ -335,7 +335,7 @@ class RenderTagTest < Minitest::Test
       refute_nil(Template.parse(template))
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/tags/table_row_test.rb

@@ -259,7 +259,7 @@ class TableRowTest < Minitest::Test
     )
   end
 
-  def test_tablerow_with_cols_attribute_in_rigid_mode
+  def test_tablerow_with_cols_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..6) cols: 3 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -270,12 +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
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_limit_attribute_in_rigid_mode
+  def test_tablerow_with_limit_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..10) limit: 3 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -285,12 +285,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_offset_attribute_in_rigid_mode
+  def test_tablerow_with_offset_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..5) offset: 2 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -300,12 +300,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">3</td><td class="col2">4</td><td class="col3">5</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_range_attribute_in_rigid_mode
+  def test_tablerow_with_range_attribute_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..3) range: (1..10) %}{{ i }}{% endtablerow %}
     LIQUID
@@ -315,12 +315,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_multiple_attributes_in_rigid_mode
+  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
@@ -331,12 +331,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">4</td><td class="col2">5</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_with_variable_collection_in_rigid_mode
+  def test_tablerow_with_variable_collection_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in numbers cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -347,12 +347,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template, { 'numbers' => [1, 2, 3, 4] })
     end
   end
 
-  def test_tablerow_with_dotted_access_in_rigid_mode
+  def test_tablerow_with_dotted_access_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in obj.numbers cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -363,12 +363,12 @@ class TableRowTest < Minitest::Test
       <tr class="row2"><td class="col1">3</td><td class="col2">4</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template, { 'obj' => { 'numbers' => [1, 2, 3, 4] } })
     end
   end
 
-  def test_tablerow_with_bracketed_access_in_rigid_mode
+  def test_tablerow_with_bracketed_access_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow n in obj["numbers"] cols: 2 %}{{ n }}{% endtablerow %}
     LIQUID
@@ -378,12 +378,12 @@ class TableRowTest < Minitest::Test
       <td class="col1">10</td><td class="col2">20</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template, { 'obj' => { 'numbers' => [10, 20] } })
     end
   end
 
-  def test_tablerow_without_attributes_in_rigid_mode
+  def test_tablerow_without_attributes_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in (1..3) %}{{ i }}{% endtablerow %}
     LIQUID
@@ -393,30 +393,30 @@ class TableRowTest < Minitest::Test
       <td class="col1">1</td><td class="col2">2</td><td class="col3">3</td></tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template)
     end
   end
 
-  def test_tablerow_without_in_keyword_in_rigid_mode
+  def test_tablerow_without_in_keyword_in_strict2_mode
     template = '{% tablerow i (1..10) %}{{ i }}{% endtablerow %}'
 
-    with_error_modes(:rigid) do
+    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_in_rigid_mode
+  def test_tablerow_with_multiple_invalid_attributes_reports_first_in_strict2_mode
     template = '{% tablerow i in (1..10) invalid1: 5, invalid2: 10 %}{{ i }}{% endtablerow %}'
 
-    with_error_modes(:rigid) do
+    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_in_rigid_mode
+  def test_tablerow_with_empty_collection_in_strict2_mode
     template = <<~LIQUID.chomp
       {% tablerow i in empty_array cols: 2 %}{{ i }}{% endtablerow %}
     LIQUID
@@ -426,12 +426,12 @@ class TableRowTest < Minitest::Test
       </tr>
     OUTPUT
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result(expected, template, { 'empty_array' => [] })
     end
   end
 
-  def test_tablerow_with_invalid_attribute_strict_vs_rigid
+  def test_tablerow_with_invalid_attribute_strict_vs_strict2
     template = '{% tablerow i in (1..5) invalid_attr: 10 %}{{ i }}{% endtablerow %}'
 
     expected = <<~OUTPUT
@@ -443,13 +443,13 @@ class TableRowTest < Minitest::Test
       assert_template_result(expected, template)
     end
 
-    with_error_modes(:rigid) do
+    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_strict_vs_rigid
+  def test_tablerow_with_invalid_expression_strict_vs_strict2
     template = '{% tablerow i in (1..5) limit: foo=>bar %}{{ i }}{% endtablerow %}'
 
     with_error_modes(:lax, :strict) do
@@ -460,7 +460,7 @@ class TableRowTest < Minitest::Test
       assert_template_result(expected, template)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(SyntaxError) { Template.parse(template) }
       assert_match(/Unexpected character =/, error.message)
     end

test/integration/variable_test.rb

@@ -218,7 +218,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('helloworld', template)
     end
   end
@@ -231,7 +231,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('hello12', template)
     end
   end
@@ -244,7 +244,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('TEST', template)
     end
   end
@@ -257,7 +257,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('TESTX', template)
     end
   end
@@ -270,7 +270,7 @@ class VariableTest < Minitest::Test
       assert_match(/is not a valid expression/, error.message)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       assert_template_result('TESTX', template)
     end
   end

test/test_helper.rb

@@ -199,6 +199,26 @@ class ErrorDrop < Liquid::Drop
   end
 end
 
+class CustomToLiquidDrop < Liquid::Drop
+  def initialize(value)
+    @value = value
+    super()
+  end
+
+  def to_liquid
+    @value
+  end
+end
+
+class HashWithCustomToS < Hash
+  def to_s
+    "kewl"
+  end
+end
+
+class HashWithoutCustomToS < Hash
+end
+
 class StubFileSystem
   attr_reader :file_read_count
 

test/unit/condition_unit_test.rb

@@ -176,19 +176,19 @@ class ConditionUnitTest < Minitest::Test
     assert_equal(['title'], result.lookups)
   end
 
-  def test_parse_expression_in_rigid_mode_raises_internal_error
-    environment = Environment.build(error_mode: :rigid)
+  def test_parse_expression_in_strict2_mode_raises_internal_error
+    environment = Environment.build(error_mode: :strict2)
     parse_context = ParseContext.new(environment: environment)
 
     error = assert_raises(Liquid::InternalError) do
       Condition.parse_expression(parse_context, 'product.title')
     end
 
-    assert_match(/unsafe parse_expression cannot be used in rigid mode/, error.message)
+    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
   end
 
-  def test_parse_expression_with_safe_true_in_rigid_mode
-    environment = Environment.build(error_mode: :rigid)
+  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)
 

test/unit/parse_context_unit_test.rb

@@ -9,32 +9,32 @@ class ParseContextUnitTest < Minitest::Test
     parser_strict = strict_parse_context.new_parser('product.title')
     result_strict = strict_parse_context.safe_parse_expression(parser_strict)
 
-    parser_rigid = rigid_parse_context.new_parser('product.title')
-    result_rigid = rigid_parse_context.safe_parse_expression(parser_rigid)
+    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_rigid)
-    assert_equal('product', result_rigid.name)
-    assert_equal(['title'], result_rigid.lookups)
+    assert_instance_of(VariableLookup, result_strict2)
+    assert_equal('product', result_strict2.name)
+    assert_equal(['title'], result_strict2.lookups)
   end
 
   def test_safe_parse_expression_raises_syntax_error_for_invalid_expression
     parser_strict = strict_parse_context.new_parser('')
-    parser_rigid = rigid_parse_context.new_parser('')
+    parser_strict2 = strict2_parse_context.new_parser('')
 
     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_rigid = assert_raises(Liquid::SyntaxError) do
-      rigid_parse_context.safe_parse_expression(parser_rigid)
+    error_strict2 = assert_raises(Liquid::SyntaxError) do
+      strict2_parse_context.safe_parse_expression(parser_strict2)
     end
 
-    assert_match(/is not a valid expression/, error_rigid.message)
+    assert_match(/is not a valid expression/, error_strict2.message)
   end
 
   def test_parse_expression_with_variable_lookup
@@ -45,10 +45,10 @@ class ParseContextUnitTest < Minitest::Test
     assert_equal(['title'], result_strict.lookups)
 
     error = assert_raises(Liquid::InternalError) do
-      rigid_parse_context.parse_expression('product.title')
+      strict2_parse_context.parse_expression('product.title')
     end
 
-    assert_match(/unsafe parse_expression cannot be used in rigid mode/, error.message)
+    assert_match(/unsafe parse_expression cannot be used in strict2 mode/, error.message)
   end
 
   def test_parse_expression_with_safe_true
@@ -58,11 +58,11 @@ class ParseContextUnitTest < Minitest::Test
     assert_equal('product', result_strict.name)
     assert_equal(['title'], result_strict.lookups)
 
-    result_rigid = rigid_parse_context.parse_expression('product.title', safe: true)
+    result_strict2 = strict2_parse_context.parse_expression('product.title', safe: true)
 
-    assert_instance_of(VariableLookup, result_rigid)
-    assert_equal('product', result_rigid.name)
-    assert_equal(['title'], result_rigid.lookups)
+    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
@@ -70,40 +70,40 @@ class ParseContextUnitTest < Minitest::Test
     assert_nil(result_strict)
 
     error = assert_raises(Liquid::InternalError) do
-      rigid_parse_context.parse_expression('')
+      strict2_parse_context.parse_expression('')
     end
 
-    assert_match(/unsafe parse_expression cannot be used in rigid mode/, error.message)
+    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_rigid = rigid_parse_context.parse_expression('', safe: true)
-    assert_nil(result_rigid)
+    result_strict2 = strict2_parse_context.parse_expression('', safe: true)
+    assert_nil(result_strict2)
   end
 
   def test_safe_parse_expression_advances_parser_pointer
-    parser = rigid_parse_context.new_parser('foo, bar')
+    parser = strict2_parse_context.new_parser('foo, bar')
 
     # safe_parse_expression consumes "foo"
-    first_result = rigid_parse_context.safe_parse_expression(parser)
+    first_result = strict2_parse_context.safe_parse_expression(parser)
     assert_instance_of(VariableLookup, first_result)
     assert_equal('foo', first_result.name)
 
     parser.consume(:comma)
 
     # safe_parse_expression consumes "bar"
-    second_result = rigid_parse_context.safe_parse_expression(parser)
+    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_rigid_mode
-    result = rigid_parse_context.parse_expression('   ', safe: true)
+  def test_parse_expression_with_whitespace_in_strict2_mode
+    result = strict2_parse_context.parse_expression('   ', safe: true)
     assert_nil(result)
   end
 
@@ -115,9 +115,9 @@ class ParseContextUnitTest < Minitest::Test
     )
   end
 
-  def rigid_parse_context
-    @rigid_parse_context ||= ParseContext.new(
-      environment: Environment.build(error_mode: :rigid),
+  def strict2_parse_context
+    @strict2_parse_context ||= ParseContext.new(
+      environment: Environment.build(error_mode: :strict2),
     )
   end
 end

test/unit/partial_cache_unit_test.rb

@@ -184,7 +184,7 @@ class PartialCacheUnitTest < Minitest::Test
       },
     )
 
-    [:lax, :warn, :strict, :rigid].each do |error_mode|
+    [:lax, :warn, :strict, :strict2].each do |error_mode|
       Liquid::PartialCache.load(
         'my_partial',
         context: context,
@@ -193,7 +193,7 @@ class PartialCacheUnitTest < Minitest::Test
     end
 
     assert_equal(
-      ["my_partial:lax", "my_partial:warn", "my_partial:strict", "my_partial:rigid"],
+      ["my_partial:lax", "my_partial:warn", "my_partial:strict", "my_partial:strict2"],
       context.registers[:cached_partials].keys,
     )
   end

test/unit/tags/case_tag_unit_test.rb

@@ -24,7 +24,7 @@ class CaseTagUnitTest < Minitest::Test
       assert_template_result("one", template)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Expected end_of_string but found/, error.message)
@@ -45,7 +45,7 @@ class CaseTagUnitTest < Minitest::Test
       assert_template_result("one", template)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Expected end_of_string but found/, error.message)
@@ -62,7 +62,7 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_modes(:lax, :strict, :rigid) do
+    with_error_modes(:lax, :strict, :strict2) do
       assert_template_result("one", template)
     end
   end
@@ -77,11 +77,31 @@ class CaseTagUnitTest < Minitest::Test
       {%- endcase -%}
     LIQUID
 
-    with_error_modes(:lax, :strict, :rigid) do
+    with_error_modes(:lax, :strict, :strict2) do
       assert_template_result("one", template)
     end
   end
 
+  def test_case_when_empty
+    template = <<~LIQUID
+      {%- case x -%}
+        {%- when 2 or empty -%}
+          2 or empty
+        {%- else -%}
+          not 2 or empty
+      {%- endcase -%}
+    LIQUID
+
+    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
     template = <<~LIQUID
       {%- case foo=>bar -%}
@@ -97,7 +117,7 @@ class CaseTagUnitTest < Minitest::Test
       assert_template_result("one", template, assigns)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Unexpected character =/, error.message)
@@ -119,7 +139,7 @@ class CaseTagUnitTest < Minitest::Test
       assert_template_result("one", template, assigns)
     end
 
-    with_error_modes(:rigid) do
+    with_error_modes(:strict2) do
       error = assert_raises(Liquid::SyntaxError) { Template.parse(template) }
 
       assert_match(/Unexpected character =/, error.message)

test/unit/variable_unit_test.rb

@@ -161,8 +161,8 @@ class VariableUnitTest < Minitest::Test
     end
   end
 
-  def test_rigid_filter_argument_parsing
-    with_error_modes(:rigid) do
+  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)