Remove :lax, :strict and :warn error modes

test/integration/assign_test.rb

@@ -41,11 +41,10 @@ class AssignTest < Minitest::Test
 
   def test_assign_uses_error_mode
     assert_match_syntax_error(
-      "Expected dotdot but found pipe in ",
+      "Expected dotdot but found pipe",
       "{% assign foo = ('X' | downcase) %}",
-      error_mode: :strict,
+      error_mode: :rigid,
     )
-    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,7 +632,7 @@ class ContextTest < Minitest::Test
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_modes(:strict) do
+    with_error_modes(:rigid) do
       context = Context.new
       context.key?('unknown')
       assert_empty(context.errors)

test/integration/error_handling_test.rb

@@ -67,20 +67,13 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_unrecognized_operator
-    with_error_modes(:strict) do
+    with_error_modes(:rigid) 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
@@ -104,25 +97,6 @@ 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(
@@ -133,7 +107,7 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
                 ',
-        error_mode: :strict,
+        error_mode: :rigid,
         line_numbers: true,
       )
     end
@@ -157,34 +131,16 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_strict_error_messages
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
+      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :rigid)
     end
     assert_equal('Liquid syntax error: Unexpected character = in "1 =! 2"', err.message)
 
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
+      Liquid::Template.parse('{{%%%}}', error_mode: :rigid)
     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,11 +27,6 @@ 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
@@ -56,19 +51,6 @@ class ExpressionTest < Minitest::Test
     )
   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
 

test/integration/parsing_quirks_test.rb

@@ -31,18 +31,14 @@ class ParsingQuirksTest < Minitest::Test
   def test_error_on_empty_filter
     assert(Template.parse("{{test}}"))
 
-    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|}}") }
+    with_error_modes(:rigid) do
+      assert_raises(Liquid::SyntaxError) { Template.parse("{{|test}}") }
+      assert_raises(Liquid::SyntaxError) { Template.parse("{{test |a|b|}}") }
     end
   end
 
   def test_meaningless_parens_error
-    with_error_modes(:strict) do
+    with_error_modes(:rigid) do
       assert_raises(SyntaxError) do
         markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
@@ -51,7 +47,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_unexpected_characters_syntax_error
-    with_error_modes(:strict) do
+    with_error_modes(:rigid) do
       assert_raises(SyntaxError) do
         markup = "true && false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
@@ -63,61 +59,12 @@ class ParsingQuirksTest < Minitest::Test
     end
   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"
-      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
-    end
-  end
-
   def test_raise_on_invalid_tag_delimiter
     assert_raises(Liquid::SyntaxError) do
       Template.new.parse('{% end %}')
     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
@@ -131,24 +78,4 @@ 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/tags/cycle_tag_test.rb

@@ -96,11 +96,6 @@ class CycleTagTest < Minitest::Test
     template1 = "{% assign 5 = 'b' %}{% cycle .5, .4 %}"
     template2 = "{% cycle .5: 'a', 'b' %}"
 
-    with_error_modes(:lax, :strict) do
-      assert_template_result("b", template1)
-      assert_template_result("a", template2)
-    end
-
     with_error_modes(:strict2) do
       error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
       error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
@@ -121,14 +116,6 @@ class CycleTagTest < Minitest::Test
     template4 = "#{assignments}{% cycle n  e: 'a', 'b', 'c' %}"
     template5 = "#{assignments}{% cycle n  e  'a', 'b', 'c' %}"
 
-    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
-
     with_error_modes(:strict2) do
       error1 = assert_raises(Liquid::SyntaxError) { Template.parse(template1) }
       error2 = assert_raises(Liquid::SyntaxError) { Template.parse(template2) }
@@ -153,10 +140,6 @@ class CycleTagTest < Minitest::Test
       {% endfor %}
     LIQUID
 
-    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)
@@ -170,10 +153,6 @@ class CycleTagTest < Minitest::Test
       {% endfor %}
     LIQUID
 
-    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)

test/integration/tags/include_tag_test.rb

@@ -205,14 +205,6 @@ class IncludeTagTest < Minitest::Test
   end
 
   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" %}',
@@ -301,16 +293,10 @@ class IncludeTagTest < Minitest::Test
     env = Liquid::Environment.build(file_system: TestFileSystem.new)
 
     assert_raises(Liquid::SyntaxError) do
-      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 }}'))
+      Template.parse("{% include template %}", error_mode: :rigid, environment: env).render!("template" => '{{ "X" || downcase }}')
     end
     assert_raises(Liquid::SyntaxError) do
-      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 }}'))
+      Template.parse("{% include template %}", error_mode: :rigid, include_options_blacklist: [:locale], environment: env).render!("template" => '{{ "X" || downcase }}')
     end
   end
 
@@ -404,10 +390,6 @@ class IncludeTagTest < Minitest::Test
   def test_include_template_with_invalid_expression
     template = "{% include foo=>bar %}"
 
-    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)
@@ -417,10 +399,6 @@ class IncludeTagTest < Minitest::Test
   def test_include_with_invalid_expression
     template = '{% include "snippet" with foo=>bar %}'
 
-    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)
@@ -430,10 +408,6 @@ class IncludeTagTest < Minitest::Test
   def test_include_attribute_with_invalid_expression
     template = '{% include "snippet", key: foo=>bar %}'
 
-    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)

test/integration/tags/render_tag_test.rb

@@ -106,14 +106,6 @@ class RenderTagTest < Minitest::Test
   end
 
   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" %}',
@@ -318,10 +310,6 @@ class RenderTagTest < Minitest::Test
   def test_render_with_invalid_expression
     template = '{% render "snippet" with foo=>bar %}'
 
-    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)
@@ -331,10 +319,6 @@ class RenderTagTest < Minitest::Test
   def test_render_attribute_with_invalid_expression
     template = '{% render "snippet", key: foo=>bar %}'
 
-    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)

test/integration/tags/table_row_test.rb

@@ -188,29 +188,6 @@ 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",
@@ -439,10 +416,6 @@ class TableRowTest < Minitest::Test
       <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)
@@ -452,14 +425,6 @@ class TableRowTest < Minitest::Test
   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
-      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)

test/integration/template_test.rb

@@ -259,7 +259,7 @@ class TemplateTest < Minitest::Test
   end
 
   def test_nil_value_does_not_raise
-    t      = Template.parse("some{{x}}thing", error_mode: :strict)
+    t      = Template.parse("some{{x}}thing", error_mode: :rigid)
     result = t.render!({ 'x' => nil }, strict_variables: true)
 
     assert_equal(0, t.errors.count)

test/integration/variable_test.rb

@@ -176,48 +176,9 @@ 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", }}'
 
-    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
@@ -226,11 +187,6 @@ class VariableTest < Minitest::Test
   def test_multiple_filters_with_trailing_commas
     template = '{{ "hello" | append: "1", | append: "2", }}'
 
-    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
@@ -239,11 +195,6 @@ class VariableTest < Minitest::Test
   def test_filter_with_colon_but_no_arguments
     template = '{{ "test" | upcase: }}'
 
-    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
@@ -252,11 +203,6 @@ class VariableTest < Minitest::Test
   def test_filter_chain_with_colon_no_args
     template = '{{ "test" | append: "x" | upcase: }}'
 
-    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
@@ -265,11 +211,6 @@ class VariableTest < Minitest::Test
   def test_combining_trailing_comma_and_empty_args
     template = '{{ "test" | append: "x", | upcase: }}'
 
-    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