From a336a2fffd01f9320eb023f92eb93a5a450dfc8e Mon Sep 17 00:00:00 2001 From: Guilherme Carreiro Date: Wed, 19 Nov 2025 13:24:55 +0100 Subject: [PATCH] Rename rigid to strict2 mode --- README.md | 8 ++-- Rakefile | 16 +++---- bin/render | 2 +- lib/liquid/environment.rb | 2 +- lib/liquid/parse_context.rb | 8 ++-- lib/liquid/parser_switching.rb | 28 ++++++++---- lib/liquid/tags/case.rb | 8 ++-- lib/liquid/tags/cycle.rb | 2 +- lib/liquid/tags/for.rb | 2 +- lib/liquid/tags/if.rb | 2 +- lib/liquid/tags/include.rb | 2 +- lib/liquid/tags/render.rb | 6 +-- lib/liquid/tags/table_row.rb | 2 +- lib/liquid/template.rb | 2 +- lib/liquid/variable.rb | 6 +-- test/integration/tags/cycle_tag_test.rb | 8 ++-- test/integration/tags/include_tag_test.rb | 10 ++-- test/integration/tags/render_tag_test.rb | 8 ++-- test/integration/tags/table_row_test.rb | 56 +++++++++++------------ test/integration/variable_test.rb | 10 ++-- test/unit/condition_unit_test.rb | 10 ++-- test/unit/parse_context_unit_test.rb | 54 +++++++++++----------- test/unit/partial_cache_unit_test.rb | 4 +- test/unit/tags/case_tag_unit_test.rb | 12 ++--- test/unit/variable_unit_test.rb | 4 +- 25 files changed, 140 insertions(+), 132 deletions(-) diff --git a/README.md b/README.md index 34884464..5066dc65 100644 --- a/README.md +++ b/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`: diff --git a/Rakefile b/Rakefile index 878536bf..83afcbfa 100755 --- a/Rakefile +++ b/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 diff --git a/bin/render b/bin/render index 26d9b53d..012b2717 100755 --- a/bin/render +++ b/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) diff --git a/lib/liquid/environment.rb b/lib/liquid/environment.rb index 59719c4a..100bd0bb 100644 --- a/lib/liquid/environment.rb +++ b/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. diff --git a/lib/liquid/parse_context.rb b/lib/liquid/parse_context.rb index 47612339..855acc64 100644 --- a/lib/liquid/parse_context.rb +++ b/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) diff --git a/lib/liquid/parser_switching.rb b/lib/liquid/parser_switching.rb index 7c662e92..e419dc99 100644 --- a/lib/liquid/parser_switching.rb +++ b/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) diff --git a/lib/liquid/tags/case.rb b/lib/liquid/tags/case.rb index 926e4107..b32ea1ae 100644 --- a/lib/liquid/tags/case.rb +++ b/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,14 +107,14 @@ 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 diff --git a/lib/liquid/tags/cycle.rb b/lib/liquid/tags/cycle.rb index 7e17a966..b7d3069c 100644 --- a/lib/liquid/tags/cycle.rb +++ b/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 = [] diff --git a/lib/liquid/tags/for.rb b/lib/liquid/tags/for.rb index da06d64a..cbea85bc 100644 --- a/lib/liquid/tags/for.rb +++ b/lib/liquid/tags/for.rb @@ -111,7 +111,7 @@ module Liquid private - def rigid_parse(markup) + def strict2_parse(markup) strict_parse(markup) end diff --git a/lib/liquid/tags/if.rb b/lib/liquid/tags/if.rb index e25d6250..c423c1e8 100644 --- a/lib/liquid/tags/if.rb +++ b/lib/liquid/tags/if.rb @@ -66,7 +66,7 @@ module Liquid private - def rigid_parse(markup) + def strict2_parse(markup) strict_parse(markup) end diff --git a/lib/liquid/tags/include.rb b/lib/liquid/tags/include.rb index 5b2aaa43..969482d4 100644 --- a/lib/liquid/tags/include.rb +++ b/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) diff --git a/lib/liquid/tags/render.rb b/lib/liquid/tags/render.rb index 4d29e420..6e1559cc 100644 --- a/lib/liquid/tags/render.rb +++ b/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 diff --git a/lib/liquid/tags/table_row.rb b/lib/liquid/tags/table_row.rb index 7348b5d9..b69f9148 100644 --- a/lib/liquid/tags/table_row.rb +++ b/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) diff --git a/lib/liquid/template.rb b/lib/liquid/template.rb index 5d349abd..b007765c 100644 --- a/lib/liquid/template.rb +++ b/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 diff --git a/lib/liquid/variable.rb b/lib/liquid/variable.rb index 3fd947a7..6b5fb412 100644 --- a/lib/liquid/variable.rb +++ b/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 = {} diff --git a/test/integration/tags/cycle_tag_test.rb b/test/integration/tags/cycle_tag_test.rb index f3f865f0..dfb5984d 100644 --- a/test/integration/tags/cycle_tag_test.rb +++ b/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 diff --git a/test/integration/tags/include_tag_test.rb b/test/integration/tags/include_tag_test.rb index 3ccd1779..44c0dcda 100644 --- a/test/integration/tags/include_tag_test.rb +++ b/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 diff --git a/test/integration/tags/render_tag_test.rb b/test/integration/tags/render_tag_test.rb index d6453fb5..0bd09d08 100644 --- a/test/integration/tags/render_tag_test.rb +++ b/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 diff --git a/test/integration/tags/table_row_test.rb b/test/integration/tags/table_row_test.rb index 44cdcdd9..45628ce9 100644 --- a/test/integration/tags/table_row_test.rb +++ b/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 456 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 123 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 345 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 123 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 45 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 34 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 34 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 1020 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 123 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 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 diff --git a/test/integration/variable_test.rb b/test/integration/variable_test.rb index f0f2bc40..e272b96b 100644 --- a/test/integration/variable_test.rb +++ b/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 diff --git a/test/unit/condition_unit_test.rb b/test/unit/condition_unit_test.rb index f5206ff5..eb466f7a 100644 --- a/test/unit/condition_unit_test.rb +++ b/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) diff --git a/test/unit/parse_context_unit_test.rb b/test/unit/parse_context_unit_test.rb index b1c8fe47..f53cd114 100644 --- a/test/unit/parse_context_unit_test.rb +++ b/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 diff --git a/test/unit/partial_cache_unit_test.rb b/test/unit/partial_cache_unit_test.rb index 31790b0d..623241b4 100644 --- a/test/unit/partial_cache_unit_test.rb +++ b/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 diff --git a/test/unit/tags/case_tag_unit_test.rb b/test/unit/tags/case_tag_unit_test.rb index 5e181f3e..9d7d34a3 100644 --- a/test/unit/tags/case_tag_unit_test.rb +++ b/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,7 +77,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 @@ -97,7 +97,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 +119,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) diff --git a/test/unit/variable_unit_test.rb b/test/unit/variable_unit_test.rb index cb3a6d8c..03f5862a 100644 --- a/test/unit/variable_unit_test.rb +++ b/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)