From 9ab688eada7f5b2245998cdff7c9bc06b63a422f Mon Sep 17 00:00:00 2001 From: Guilherme Carreiro Date: Wed, 15 Feb 2023 08:40:59 +0100 Subject: [PATCH] Update `rubocop-shopify` (2.7.0 -> 2.12.0) (#1687) --- .rubocop.yml | 11 +- Gemfile | 2 +- example/server/example_servlet.rb | 14 +- lib/liquid/block.rb | 12 +- lib/liquid/condition.rb | 6 +- lib/liquid/context.rb | 2 +- lib/liquid/expression.rb | 5 +- lib/liquid/standardfilters.rb | 2 +- lib/liquid/tags/case.rb | 2 +- lib/liquid/tags/if.rb | 2 +- lib/liquid/tags/include.rb | 2 +- lib/liquid/tags/render.rb | 2 +- lib/liquid/tags/unless.rb | 4 +- performance/shopify/paginate.rb | 4 +- test/integration/assign_test.rb | 25 ++- test/integration/blank_test.rb | 27 ++- test/integration/context_test.rb | 56 +++-- test/integration/error_handling_test.rb | 18 +- test/integration/expression_test.rb | 4 +- test/integration/filter_kwarg_test.rb | 2 +- test/integration/filter_test.rb | 49 +++-- test/integration/standard_filter_test.rb | 20 +- test/integration/tags/for_tag_test.rb | 42 ++-- test/integration/tags/if_else_tag_test.rb | 24 ++- test/integration/tags/include_tag_test.rb | 192 ++++++++++++------ test/integration/tags/increment_tag_test.rb | 12 +- test/integration/tags/raw_tag_test.rb | 6 +- test/integration/tags/render_tag_test.rb | 154 +++++++++----- test/integration/tags/standard_tag_test.rb | 157 +++++++++----- test/integration/tags/table_row_test.rb | 90 +++++--- test/integration/tags/unless_else_tag_test.rb | 6 +- test/integration/template_test.rb | 10 +- test/integration/variable_test.rb | 6 +- test/unit/block_unit_test.rb | 6 +- test/unit/condition_unit_test.rb | 12 +- test/unit/parse_tree_visitor_test.rb | 72 +++---- test/unit/partial_cache_unit_test.rb | 40 ++-- test/unit/strainer_factory_unit_test.rb | 2 +- 38 files changed, 720 insertions(+), 382 deletions(-) diff --git a/.rubocop.yml b/.rubocop.yml index fec517c5..f917cc52 100644 --- a/.rubocop.yml +++ b/.rubocop.yml @@ -12,6 +12,7 @@ Performance: AllCops: TargetRubyVersion: 2.7 NewCops: disable + SuggestExtensions: false Exclude: - 'vendor/bundle/**/*' @@ -19,6 +20,10 @@ Naming/MethodName: Exclude: - 'example/server/liquid_servlet.rb' -# Backport https://github.com/Shopify/ruby-style-guide/pull/258 -Layout/BeginEndAlignment: - Enabled: true +Style/ClassMethodsDefinitions: + Enabled: false + +# liquid filter calls were being mistaken to be calls on arrays +Style/ConcatArrayLiterals: + Exclude: + - 'test/integration/standard_filter_test.rb' diff --git a/Gemfile b/Gemfile index 29c25b90..31561a9e 100644 --- a/Gemfile +++ b/Gemfile @@ -19,7 +19,7 @@ end group :test do gem 'rubocop', '~> 1.44.0' - gem 'rubocop-shopify', '~> 2.7.0', require: false + gem 'rubocop-shopify', '~> 2.12.0', require: false gem 'rubocop-performance', require: false platform :mri, :truffleruby do diff --git a/example/server/example_servlet.rb b/example/server/example_servlet.rb index b09e3bb7..d2d4fd6a 100644 --- a/example/server/example_servlet.rb +++ b/example/server/example_servlet.rb @@ -30,14 +30,18 @@ class Servlet < LiquidServlet private def products_list - [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' }, - { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' }, - { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }] + [ + { 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' }, + { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' }, + { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' } + ] end def more_products_list - [{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' }, - { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }] + [ + { 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' }, + { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' } + ] end def description diff --git a/lib/liquid/block.rb b/lib/liquid/block.rb index dc22a477..73d86c7b 100644 --- a/lib/liquid/block.rb +++ b/lib/liquid/block.rb @@ -36,13 +36,17 @@ module Liquid # @api private def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context) if tag == 'else' - raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else", - block_name: block_name) + raise SyntaxError, parse_context.locale.t( + "errors.syntax.unexpected_else", + block_name: block_name, + ) elsif tag.start_with?('end') - raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter", + raise SyntaxError, parse_context.locale.t( + "errors.syntax.invalid_delimiter", tag: tag, block_name: block_name, - block_delimiter: block_delimiter) + block_delimiter: block_delimiter, + ) else raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag) end diff --git a/lib/liquid/condition.rb b/lib/liquid/condition.rb index 595f1713..c1476dd4 100644 --- a/lib/liquid/condition.rb +++ b/lib/liquid/condition.rb @@ -159,8 +159,10 @@ module Liquid class ParseTreeVisitor < Liquid::ParseTreeVisitor def children [ - @node.left, @node.right, - @node.child_condition, @node.attachment + @node.left, + @node.right, + @node.child_condition, + @node.attachment ].compact end end diff --git a/lib/liquid/context.rb b/lib/liquid/context.rb index 36d3868b..5b1a01ee 100644 --- a/lib/liquid/context.rb +++ b/lib/liquid/context.rb @@ -144,7 +144,7 @@ module Liquid self.class.build( resource_limits: resource_limits, static_environments: static_environments, - registers: Registers.new(registers) + registers: Registers.new(registers), ).tap do |subcontext| subcontext.base_scope_depth = base_scope_depth + 1 subcontext.exception_renderer = exception_renderer diff --git a/lib/liquid/expression.rb b/lib/liquid/expression.rb index fcdd4d8a..a1426732 100644 --- a/lib/liquid/expression.rb +++ b/lib/liquid/expression.rb @@ -3,7 +3,10 @@ module Liquid class Expression LITERALS = { - nil => nil, 'nil' => nil, 'null' => nil, '' => nil, + nil => nil, + 'nil' => nil, + 'null' => nil, + '' => nil, 'true' => true, 'false' => false, 'blank' => '', diff --git a/lib/liquid/standardfilters.rb b/lib/liquid/standardfilters.rb index 50be86d7..53662fef 100644 --- a/lib/liquid/standardfilters.rb +++ b/lib/liquid/standardfilters.rb @@ -25,7 +25,7 @@ module Liquid STRIP_HTML_BLOCKS = Regexp.union( %r{}m, //m, - %r{}m + %r{}m, ) STRIP_HTML_TAGS = /<.*?>/m diff --git a/lib/liquid/tags/case.rb b/lib/liquid/tags/case.rb index 910dd6eb..4fe4cd98 100644 --- a/lib/liquid/tags/case.rb +++ b/lib/liquid/tags/case.rb @@ -77,7 +77,7 @@ module Liquid end result = Liquid::Utils.to_liquid_value( - block.evaluate(context) + block.evaluate(context), ) if result diff --git a/lib/liquid/tags/if.rb b/lib/liquid/tags/if.rb index d15173f8..a5cc8469 100644 --- a/lib/liquid/tags/if.rb +++ b/lib/liquid/tags/if.rb @@ -53,7 +53,7 @@ module Liquid def render_to_output_buffer(context, output) @blocks.each do |block| result = Liquid::Utils.to_liquid_value( - block.evaluate(context) + block.evaluate(context), ) if result diff --git a/lib/liquid/tags/include.rb b/lib/liquid/tags/include.rb index f667b962..5b3ad8e0 100644 --- a/lib/liquid/tags/include.rb +++ b/lib/liquid/tags/include.rb @@ -57,7 +57,7 @@ module Liquid partial = PartialCache.load( template_name, context: context, - parse_context: parse_context + parse_context: parse_context, ) context_variable_name = @alias_name || template_name.split('/').last diff --git a/lib/liquid/tags/render.rb b/lib/liquid/tags/render.rb index 967674c1..0dc7215d 100644 --- a/lib/liquid/tags/render.rb +++ b/lib/liquid/tags/render.rb @@ -69,7 +69,7 @@ module Liquid partial = PartialCache.load( template_name, context: context, - parse_context: parse_context + parse_context: parse_context, ) context_variable_name = @alias_name || template_name.split('/').last diff --git a/lib/liquid/tags/unless.rb b/lib/liquid/tags/unless.rb index 74c39587..2fc79db5 100644 --- a/lib/liquid/tags/unless.rb +++ b/lib/liquid/tags/unless.rb @@ -23,7 +23,7 @@ module Liquid # First condition is interpreted backwards ( if not ) first_block = @blocks.first result = Liquid::Utils.to_liquid_value( - first_block.evaluate(context) + first_block.evaluate(context), ) unless result @@ -33,7 +33,7 @@ module Liquid # After the first condition unless works just like if @blocks[1..-1].each do |block| result = Liquid::Utils.to_liquid_value( - block.evaluate(context) + block.evaluate(context), ) if result diff --git a/performance/shopify/paginate.rb b/performance/shopify/paginate.rb index fb503357..3154d183 100644 --- a/performance/shopify/paginate.rb +++ b/performance/shopify/paginate.rb @@ -45,8 +45,8 @@ class Paginate < Liquid::Block pagination['items'] = collection_size pagination['pages'] = page_count - 1 - pagination['previous'] = link('« Previous', current_page - 1) unless 1 >= current_page - pagination['next'] = link('Next »', current_page + 1) unless page_count <= current_page + 1 + pagination['previous'] = link('« Previous', current_page - 1) if 1 < current_page + pagination['next'] = link('Next »', current_page + 1) if page_count > current_page + 1 pagination['parts'] = [] hellip_break = false diff --git a/test/integration/assign_test.rb b/test/integration/assign_test.rb index ba795fbb..fdb6c99c 100644 --- a/test/integration/assign_test.rb +++ b/test/integration/assign_test.rb @@ -14,19 +14,25 @@ class AssignTest < Minitest::Test end def test_assigned_variable - assert_template_result('.foo.', + assert_template_result( + '.foo.', '{% assign foo = values %}.{{ foo[0] }}.', - { 'values' => %w(foo bar baz) }) + { 'values' => %w(foo bar baz) }, + ) - assert_template_result('.bar.', + assert_template_result( + '.bar.', '{% assign foo = values %}.{{ foo[1] }}.', - { 'values' => %w(foo bar baz) }) + { 'values' => %w(foo bar baz) }, + ) end def test_assign_with_filter - assert_template_result('.bar.', + assert_template_result( + '.bar.', '{% assign foo = values | split: "," %}.{{ foo[1] }}.', - { 'values' => "foo,bar,baz" }) + { 'values' => "foo,bar,baz" }, + ) end def test_assign_syntax_error @@ -34,8 +40,11 @@ class AssignTest < Minitest::Test end def test_assign_uses_error_mode - assert_match_syntax_error("Expected dotdot but found pipe in ", - "{% assign foo = ('X' | downcase) %}", error_mode: :strict) + assert_match_syntax_error( + "Expected dotdot but found pipe in ", + "{% assign foo = ('X' | downcase) %}", + error_mode: :strict, + ) assert_template_result("", "{% assign foo = ('X' | downcase) %}", error_mode: :lax) end diff --git a/test/integration/blank_test.rb b/test/integration/blank_test.rb index be645450..9705d3b5 100644 --- a/test/integration/blank_test.rb +++ b/test/integration/blank_test.rb @@ -57,9 +57,11 @@ class BlankTest < Minitest::Test def test_nested_blocks_are_blank_but_only_if_all_children_are assert_template_result("", wrap(wrap(" "))) - assert_template_result("\n but this is not " * (N + 1), + assert_template_result( + "\n but this is not " * (N + 1), wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %} - {% if true %} but this is not {% endif %}')) + {% if true %} but this is not {% endif %}'), + ) end def test_assigns_are_blank @@ -89,12 +91,21 @@ class BlankTest < Minitest::Test end def test_include_is_blank - assert_template_result("foobar" * (N + 1), wrap("{% include 'foobar' %}"), - partials: { 'foobar' => 'foobar' }) - assert_template_result(" foobar " * (N + 1), wrap("{% include ' foobar ' %}"), - partials: { ' foobar ' => ' foobar ' }) - assert_template_result(" " * (N + 1), wrap(" {% include ' ' %} "), - partials: { ' ' => ' ' }) + assert_template_result( + "foobar" * (N + 1), + wrap("{% include 'foobar' %}"), + partials: { 'foobar' => 'foobar' }, + ) + assert_template_result( + " foobar " * (N + 1), + wrap("{% include ' foobar ' %}"), + partials: { ' foobar ' => ' foobar ' }, + ) + assert_template_result( + " " * (N + 1), + wrap(" {% include ' ' %} "), + partials: { ' ' => ' ' }, + ) end def test_case_is_blank diff --git a/test/integration/context_test.rb b/test/integration/context_test.rb index 4bd15afc..a25362a6 100644 --- a/test/integration/context_test.rb +++ b/test/integration/context_test.rb @@ -121,14 +121,23 @@ class ContextTest < Minitest::Test end def test_length_query - assert_template_result("true", "{% if numbers.size == 4 %}true{% endif %}", - { "numbers" => [1, 2, 3, 4] }) + assert_template_result( + "true", + "{% if numbers.size == 4 %}true{% endif %}", + { "numbers" => [1, 2, 3, 4] }, + ) - assert_template_result("true", "{% if numbers.size == 4 %}true{% endif %}", - { "numbers" => { 1 => 1, 2 => 2, 3 => 3, 4 => 4 } }) + assert_template_result( + "true", + "{% if numbers.size == 4 %}true{% endif %}", + { "numbers" => { 1 => 1, 2 => 2, 3 => 3, 4 => 4 } }, + ) - assert_template_result("true", "{% if numbers.size == 1000 %}true{% endif %}", - { "numbers" => { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 } }) + assert_template_result( + "true", + "{% if numbers.size == 1000 %}true{% endif %}", + { "numbers" => { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 } }, + ) end def test_hyphenated_variable @@ -228,12 +237,14 @@ class ContextTest < Minitest::Test end def test_hash_to_array_transition - assigns = { 'colors' => { - 'Blue' => ['003366', '336699', '6699CC', '99CCFF'], - 'Green' => ['003300', '336633', '669966', '99CC99'], - 'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'], - 'Red' => ['660000', '993333', 'CC6666', 'FF9999'], - } } + assigns = { + 'colors' => { + 'Blue' => ['003366', '336699', '6699CC', '99CCFF'], + 'Green' => ['003300', '336633', '669966', '99CC99'], + 'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'], + 'Red' => ['660000', '993333', 'CC6666', 'FF9999'], + }, + } assert_template_result("003366", "{{ colors.Blue[0] }}", assigns) assert_template_result("FF9999", "{{ colors.Red[3] }}", assigns) @@ -410,10 +421,12 @@ class ContextTest < Minitest::Test def test_nested_lambda_is_called_once @global = 0 - @context['callcount'] = { "lambda" => proc { - @global += 1 - @global.to_s - } } + @context['callcount'] = { + "lambda" => proc { + @global += 1 + @global.to_s + }, + } assert_equal('1', @context['callcount.lambda']) assert_equal('1', @context['callcount.lambda']) @@ -423,10 +436,11 @@ class ContextTest < Minitest::Test def test_lambda_in_array_is_called_once @global = 0 - @context['callcount'] = [1, 2, proc { - @global += 1 - @global.to_s - }, 4, 5] + p = proc { + @global += 1 + @global.to_s + } + @context['callcount'] = [1, 2, p, 4, 5] assert_equal('1', @context['callcount[2]']) assert_equal('1', @context['callcount[2]']) @@ -473,7 +487,7 @@ class ContextTest < Minitest::Test def test_static_environments_are_read_with_lower_priority_than_environments context = Context.build( static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' }, - environments: { 'shadowed' => 'dynamic' } + environments: { 'shadowed' => 'dynamic' }, ) assert_equal('dynamic', context['shadowed']) diff --git a/test/integration/error_handling_test.rb b/test/integration/error_handling_test.rb index b7ee624d..4affac23 100644 --- a/test/integration/error_handling_test.rb +++ b/test/integration/error_handling_test.rb @@ -105,7 +105,8 @@ class ErrorHandlingTest < Minitest::Test end def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors - template = Liquid::Template.parse(' + template = Liquid::Template.parse( + ' foobar {% if 1 =! 2 %}ok{% endif %} @@ -113,15 +114,19 @@ class ErrorHandlingTest < Minitest::Test bla ', error_mode: :warn, - line_numbers: true) + line_numbers: true, + ) - assert_equal(['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'], - template.warnings.map(&:message)) + 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(' + Liquid::Template.parse( + ' foobar {% if 1 =! 2 %}ok{% endif %} @@ -129,7 +134,8 @@ class ErrorHandlingTest < Minitest::Test bla ', error_mode: :strict, - line_numbers: true) + line_numbers: true, + ) end assert_equal('Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message) diff --git a/test/integration/expression_test.rb b/test/integration/expression_test.rb index 47734484..80f6f417 100644 --- a/test/integration/expression_test.rb +++ b/test/integration/expression_test.rb @@ -32,11 +32,11 @@ class ExpressionTest < Minitest::Test assert_match_syntax_error( "Liquid syntax error (line 1): Invalid expression type 'false' in range expression", - "{{ (false..true) }}" + "{{ (false..true) }}", ) assert_match_syntax_error( "Liquid syntax error (line 1): Invalid expression type '(1..2)' in range expression", - "{{ ((1..2)..3) }}" + "{{ ((1..2)..3) }}", ) end diff --git a/test/integration/filter_kwarg_test.rb b/test/integration/filter_kwarg_test.rb index 2bd3cbdf..b41f6d67 100644 --- a/test/integration/filter_kwarg_test.rb +++ b/test/integration/filter_kwarg_test.rb @@ -17,7 +17,7 @@ class FilterKwargTest < Minitest::Test with_global_filter(KwargFilter) do assert_equal( "data-src='src' data-widths='100, 200'", - Template.parse("{{ 'img' | html_tag: data-src: 'src', data-widths: '100, 200' }}").render(nil, nil) + Template.parse("{{ 'img' | html_tag: data-src: 'src', data-widths: '100, 200' }}").render(nil, nil), ) end end diff --git a/test/integration/filter_test.rb b/test/integration/filter_test.rb index 80d652d0..133b57b3 100644 --- a/test/integration/filter_test.rb +++ b/test/integration/filter_test.rb @@ -68,22 +68,34 @@ class FiltersTest < Minitest::Test def test_sort assert_template_result("1 2 3 4", "{{numbers | sort | join}}", { "numbers" => [2, 1, 4, 3] }) - assert_template_result("alphabetic as expected", "{{words | sort | join}}", - { "words" => ['expected', 'as', 'alphabetic'] }) + assert_template_result( + "alphabetic as expected", + "{{words | sort | join}}", + { "words" => ['expected', 'as', 'alphabetic'] }, + ) assert_template_result("3", "{{value | sort}}", { "value" => 3 }) assert_template_result('are flower', "{{arrays | sort | join}}", { 'arrays' => ['flower', 'are'] }) - assert_template_result("Expected case sensitive", "{{case_sensitive | sort | join}}", - { "case_sensitive" => ["sensitive", "Expected", "case"] }) + assert_template_result( + "Expected case sensitive", + "{{case_sensitive | sort | join}}", + { "case_sensitive" => ["sensitive", "Expected", "case"] }, + ) end def test_sort_natural # Test strings - assert_template_result("Assert case Insensitive", "{{words | sort_natural | join}}", - { "words" => ["case", "Assert", "Insensitive"] }) + assert_template_result( + "Assert case Insensitive", + "{{words | sort_natural | join}}", + { "words" => ["case", "Assert", "Insensitive"] }, + ) # Test hashes - assert_template_result("A b C", "{{hashes | sort_natural: 'a' | map: 'a' | join}}", - { "hashes" => [{ "a" => "A" }, { "a" => "b" }, { "a" => "C" }] }) + assert_template_result( + "A b C", + "{{hashes | sort_natural: 'a' | map: 'a' | join}}", + { "hashes" => [{ "a" => "A" }, { "a" => "b" }, { "a" => "C" }] }, + ) # Test objects @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')] @@ -92,12 +104,18 @@ class FiltersTest < Minitest::Test def test_compact # Test strings - assert_template_result("a b c", "{{words | compact | join}}", - { "words" => ['a', nil, 'b', nil, 'c'] }) + assert_template_result( + "a b c", + "{{words | compact | join}}", + { "words" => ['a', nil, 'b', nil, 'c'] }, + ) # Test hashes - assert_template_result("A C", "{{hashes | compact: 'a' | map: 'a' | join}}", - { "hashes" => [{ "a" => "A" }, { "a" => nil }, { "a" => "C" }] }) + assert_template_result( + "A C", + "{{hashes | compact: 'a' | map: 'a' | join}}", + { "hashes" => [{ "a" => "A" }, { "a" => nil }, { "a" => "C" }] }, + ) # Test objects @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')] @@ -109,8 +127,11 @@ class FiltersTest < Minitest::Test end def test_strip_html_ignore_comments_with_html - assert_template_result("bla blub", "{{ var | strip_html }}", - { "var" => "bla blub" }) + assert_template_result( + "bla blub", + "{{ var | strip_html }}", + { "var" => "bla blub" }, + ) end def test_capitalize diff --git a/test/integration/standard_filter_test.rb b/test/integration/standard_filter_test.rb index b633024b..bc8c6a4a 100644 --- a/test/integration/standard_filter_test.rb +++ b/test/integration/standard_filter_test.rb @@ -188,7 +188,7 @@ class StandardFiltersTest < Minitest::Test def test_base64_url_safe_encode assert_equal( 'YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8', - @filters.base64_url_safe_encode('abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|') + @filters.base64_url_safe_encode('abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|'), ) assert_equal('', @filters.base64_url_safe_encode(nil)) end @@ -196,7 +196,7 @@ class StandardFiltersTest < Minitest::Test def test_base64_url_safe_decode assert_equal( 'abcdefghijklmnopqrstuvwxyz ABCDEFGHIJKLMNOPQRSTUVWXYZ 1234567890 !@#$%^&*()-=_+/?.:;[]{}\|', - @filters.base64_url_safe_decode('YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8') + @filters.base64_url_safe_decode('YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXogQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVogMTIzNDU2Nzg5MCAhQCMkJV4mKigpLT1fKy8_Ljo7W117fVx8'), ) exception = assert_raises(Liquid::ArgumentError) do @filters.base64_url_safe_decode("invalidbase64") @@ -230,7 +230,7 @@ class StandardFiltersTest < Minitest::Test assert_equal('one two three', @filters.truncatewords('one two three')) assert_equal( 'Two small (13” x 5.5” x 10” high) baskets fit inside one large basket (13”...', - @filters.truncatewords('Two small (13” x 5.5” x 10” high) baskets fit inside one large basket (13” x 16” x 10.5” high) with cover.', 15) + @filters.truncatewords('Two small (13” x 5.5” x 10” high) baskets fit inside one large basket (13” x 16” x 10.5” high) with cover.', 15), ) assert_equal("测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5)) assert_equal('one two1', @filters.truncatewords("one two three", 2, 1)) @@ -433,8 +433,11 @@ class StandardFiltersTest < Minitest::Test def test_map assert_equal([1, 2, 3, 4], @filters.map([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], 'a')) - assert_template_result('abc', "{{ ary | map:'foo' | map:'bar' }}", - { 'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }] }) + assert_template_result( + 'abc', + "{{ ary | map:'foo' | map:'bar' }}", + { 'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }] }, + ) end def test_map_doesnt_call_arbitrary_stuff @@ -458,8 +461,11 @@ class StandardFiltersTest < Minitest::Test end def test_map_on_hashes - assert_template_result("4217", '{{ thing | map: "foo" | map: "bar" }}', - { "thing" => { "foo" => [{ "bar" => 42 }, { "bar" => 17 }] } }) + assert_template_result( + "4217", + '{{ thing | map: "foo" | map: "bar" }}', + { "thing" => { "foo" => [{ "bar" => 42 }, { "bar" => 17 }] } }, + ) end def test_legacy_map_on_hashes_with_dynamic_key diff --git a/test/integration/tags/for_tag_test.rb b/test/integration/tags/for_tag_test.rb index b36a5ba2..5b81e110 100644 --- a/test/integration/tags/for_tag_test.rb +++ b/test/integration/tags/for_tag_test.rb @@ -73,9 +73,11 @@ HERE def test_for_helpers assigns = { 'array' => [1, 2, 3] } - assert_template_result(' 1/3 2/3 3/3 ', + assert_template_result( + ' 1/3 2/3 3/3 ', '{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}', - assigns) + assigns, + ) assert_template_result(' 1 2 3 ', '{%for item in array%} {{forloop.index}} {%endfor%}', assigns) assert_template_result(' 0 1 2 ', '{%for item in array%} {{forloop.index0}} {%endfor%}', assigns) assert_template_result(' 2 1 0 ', '{%for item in array%} {{forloop.rindex0}} {%endfor%}', assigns) @@ -86,9 +88,11 @@ HERE def test_for_and_if assigns = { 'array' => [1, 2, 3] } - assert_template_result('+--', + assert_template_result( + '+--', '{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}', - assigns) + assigns, + ) end def test_for_else @@ -325,15 +329,20 @@ HERE # ruby 1.9.3 no longer supports .each on String though we mimic # the functionality for backwards compatibility - assert_template_result('test string', + assert_template_result( + 'test string', '{%for val in string%}{{val}}{%endfor%}', - { 'string' => "test string" }) + { 'string' => "test string" }, + ) - assert_template_result('test string', + assert_template_result( + 'test string', '{%for val in string limit:1%}{{val}}{%endfor%}', - { 'string' => "test string" }) + { 'string' => "test string" }, + ) - assert_template_result('val-string-1-1-0-1-0-true-true-test string', + assert_template_result( + 'val-string-1-1-0-1-0-true-true-test string', '{%for val in string%}' \ '{{forloop.name}}-' \ '{{forloop.index}}-' \ @@ -344,23 +353,28 @@ HERE '{{forloop.first}}-' \ '{{forloop.last}}-' \ '{{val}}{%endfor%}', - { 'string' => "test string" }) + { 'string' => "test string" }, + ) end def test_for_parentloop_references_parent_loop - assert_template_result('1.1 1.2 1.3 2.1 2.2 2.3 ', + assert_template_result( + '1.1 1.2 1.3 2.1 2.2 2.3 ', '{% for inner in outer %}{% for k in inner %}' \ '{{ forloop.parentloop.index }}.{{ forloop.index }} ' \ '{% endfor %}{% endfor %}', - { 'outer' => [[1, 1, 1], [1, 1, 1]] }) + { 'outer' => [[1, 1, 1], [1, 1, 1]] }, + ) end def test_for_parentloop_nil_when_not_present - assert_template_result('.1 .2 ', + assert_template_result( + '.1 .2 ', '{% for inner in outer %}' \ '{{ forloop.parentloop.index }}.{{ forloop.index }} ' \ '{% endfor %}', - { 'outer' => [[1, 1, 1], [1, 1, 1]] }) + { 'outer' => [[1, 1, 1], [1, 1, 1]] }, + ) end def test_inner_for_over_empty_input diff --git a/test/integration/tags/if_else_tag_test.rb b/test/integration/tags/if_else_tag_test.rb index fcd57af8..3f04f2b8 100644 --- a/test/integration/tags/if_else_tag_test.rb +++ b/test/integration/tags/if_else_tag_test.rb @@ -7,8 +7,10 @@ class IfElseTagTest < Minitest::Test def test_if assert_template_result(' ', ' {% if false %} this text should not go into the output {% endif %} ') - assert_template_result(' this text should go into the output ', - ' {% if true %} this text should go into the output {% endif %} ') + assert_template_result( + ' this text should go into the output ', + ' {% if true %} this text should go into the output {% endif %} ', + ) assert_template_result(' you rock ?', '{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?') end @@ -51,12 +53,16 @@ class IfElseTagTest < Minitest::Test def test_comparison_of_expressions_starting_with_and_or_or assigns = { 'order' => { 'items_count' => 0 }, 'android' => { 'name' => 'Roy' } } - assert_template_result("YES", + assert_template_result( + "YES", "{% if android.name == 'Roy' %}YES{% endif %}", - assigns) - assert_template_result("YES", + assigns, + ) + assert_template_result( + "YES", "{% if order.items_count == 0 %}YES{% endif %}", - assigns) + assigns, + ) end def test_if_and @@ -155,8 +161,10 @@ class IfElseTagTest < Minitest::Test original_op = Condition.operators['contains'] Condition.operators['contains'] = :[] - assert_template_result('yes', - %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %})) + assert_template_result( + 'yes', + %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}), + ) ensure Condition.operators['contains'] = original_op end diff --git a/test/integration/tags/include_tag_test.rb b/test/integration/tags/include_tag_test.rb index 91f1aeab..442ab395 100644 --- a/test/integration/tags/include_tag_test.rb +++ b/test/integration/tags/include_tag_test.rb @@ -58,65 +58,88 @@ class IncludeTagTest < Minitest::Test end def test_include_tag_looks_for_file_system_in_registers_first - assert_equal('from OtherFileSystem', - Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: OtherFileSystem.new })) + assert_equal( + 'from OtherFileSystem', + Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: OtherFileSystem.new }), + ) end def test_include_tag_with - assert_template_result("Product: Draft 151cm ", + assert_template_result( + "Product: Draft 151cm ", "{% include 'product' with products[0] %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, - partials: { "product" => "Product: {{ product.title }} " }) + partials: { "product" => "Product: {{ product.title }} " }, + ) end def test_include_tag_with_alias - assert_template_result("Product: Draft 151cm ", + assert_template_result( + "Product: Draft 151cm ", "{% include 'product_alias' with products[0] as product %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, - partials: { "product_alias" => "Product: {{ product.title }} " }) + partials: { "product_alias" => "Product: {{ product.title }} " }, + ) end def test_include_tag_for_alias - assert_template_result("Product: Draft 151cm Product: Element 155cm ", + assert_template_result( + "Product: Draft 151cm Product: Element 155cm ", "{% include 'product_alias' for products as product %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, - partials: { "product_alias" => "Product: {{ product.title }} " }) + partials: { "product_alias" => "Product: {{ product.title }} " }, + ) end def test_include_tag_with_default_name - assert_template_result("Product: Draft 151cm ", - "{% include 'product' %}", { "product" => { 'title' => 'Draft 151cm' } }, - partials: { "product" => "Product: {{ product.title }} " }) + assert_template_result( + "Product: Draft 151cm ", + "{% include 'product' %}", + { "product" => { 'title' => 'Draft 151cm' } }, + partials: { "product" => "Product: {{ product.title }} " }, + ) end def test_include_tag_for - assert_template_result("Product: Draft 151cm Product: Element 155cm ", + assert_template_result( + "Product: Draft 151cm Product: Element 155cm ", "{% include 'product' for products %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, - partials: { "product" => "Product: {{ product.title }} " }) + partials: { "product" => "Product: {{ product.title }} " }, + ) end def test_include_tag_with_local_variables - assert_template_result("Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}", - partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" }) + assert_template_result( + "Locale: test123 ", + "{% include 'locale_variables' echo1: 'test123' %}", + partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" }, + ) end def test_include_tag_with_multiple_local_variables - assert_template_result("Locale: test123 test321", + assert_template_result( + "Locale: test123 test321", "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}", - partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" }) + partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" }, + ) end def test_include_tag_with_multiple_local_variables_from_context - assert_template_result("Locale: test123 test321", + assert_template_result( + "Locale: test123 test321", "{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}", { 'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' } }, - partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" }) + partials: { "locale_variables" => "Locale: {{echo1}} {{echo2}}" }, + ) end def test_included_templates_assigns_variables - assert_template_result("bar", "{% include 'assignments' %}{{ foo }}", - partials: { 'assignments' => "{% assign foo = 'bar' %}" }) + assert_template_result( + "bar", + "{% include 'assignments' %}{{ foo }}", + partials: { 'assignments' => "{% assign foo = 'bar' %}" }, + ) end def test_nested_include_tag @@ -137,13 +160,19 @@ class IncludeTagTest < Minitest::Test "details" => "details", } - assert_template_result("Product: Draft 151cm details ", - "{% include 'nested_product_template' with product %}", { "product" => { "title" => 'Draft 151cm' } }, - partials: partials) + assert_template_result( + "Product: Draft 151cm details ", + "{% include 'nested_product_template' with product %}", + { "product" => { "title" => 'Draft 151cm' } }, + partials: partials, + ) - assert_template_result("Product: Draft 151cm details Product: Element 155cm details ", - "{% include 'nested_product_template' for products %}", { "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }] }, - partials: partials) + assert_template_result( + "Product: Draft 151cm details Product: Element 155cm details ", + "{% include 'nested_product_template' for products %}", + { "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }] }, + partials: partials, + ) end def test_recursively_included_template_does_not_produce_endless_loop @@ -161,46 +190,68 @@ class IncludeTagTest < Minitest::Test end def test_dynamically_choosen_template - assert_template_result("Test123", "{% include template %}", { "template" => 'Test123' }, - partials: { "Test123" => "Test123" }) + assert_template_result( + "Test123", + "{% include template %}", + { "template" => 'Test123' }, + partials: { "Test123" => "Test123" }, + ) - assert_template_result("Test321", "{% include template %}", { "template" => 'Test321' }, - partials: { "Test321" => "Test321" }) + assert_template_result( + "Test321", + "{% include template %}", + { "template" => 'Test321' }, + partials: { "Test321" => "Test321" }, + ) - assert_template_result("Product: Draft 151cm ", "{% include template for product %}", + assert_template_result( + "Product: Draft 151cm ", + "{% include template for product %}", { "template" => 'product', 'product' => { 'title' => 'Draft 151cm' } }, - partials: { "product" => "Product: {{ product.title }} " }) + partials: { "product" => "Product: {{ product.title }} " }, + ) end def test_include_tag_caches_second_read_of_same_partial file_system = CountingFileSystem.new - assert_equal('from CountingFileSystemfrom CountingFileSystem', - Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })) + assert_equal( + 'from CountingFileSystemfrom CountingFileSystem', + Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }), + ) assert_equal(1, file_system.count) end def test_include_tag_doesnt_cache_partials_across_renders file_system = CountingFileSystem.new - assert_equal('from CountingFileSystem', - Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })) + assert_equal( + 'from CountingFileSystem', + Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }), + ) assert_equal(1, file_system.count) - assert_equal('from CountingFileSystem', - Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })) + assert_equal( + 'from CountingFileSystem', + Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system }), + ) assert_equal(2, file_system.count) end def test_include_tag_within_if_statement - assert_template_result("foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}", - partials: { "foo_if_true" => "foo_if_true" }) + assert_template_result( + "foo_if_true", + "{% if true %}{% include 'foo_if_true' %}{% endif %}", + partials: { "foo_if_true" => "foo_if_true" }, + ) end def test_custom_include_tag original_tag = Liquid::Template.tags['include'] Liquid::Template.tags['include'] = CustomInclude begin - assert_equal("custom_foo", - Template.parse("{% include 'custom_foo' %}").render!) + assert_equal( + "custom_foo", + Template.parse("{% include 'custom_foo' %}").render!, + ) ensure Liquid::Template.tags['include'] = original_tag end @@ -210,8 +261,10 @@ class IncludeTagTest < Minitest::Test original_tag = Liquid::Template.tags['include'] Liquid::Template.tags['include'] = CustomInclude begin - assert_equal("custom_foo_if_true", - Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render!) + assert_equal( + "custom_foo_if_true", + Template.parse("{% if true %}{% include 'custom_foo_if_true' %}{% endif %}").render!, + ) ensure Liquid::Template.tags['include'] = original_tag end @@ -242,31 +295,49 @@ class IncludeTagTest < Minitest::Test end def test_render_raise_argument_error_when_template_is_undefined - assert_template_result("Liquid error (line 1): Argument error in tag 'include' - Illegal template name", - "{% include undefined_variable %}", render_errors: true) + assert_template_result( + "Liquid error (line 1): Argument error in tag 'include' - Illegal template name", + "{% include undefined_variable %}", + render_errors: true, + ) - assert_template_result("Liquid error (line 1): Argument error in tag 'include' - Illegal template name", - "{% include nil %}", render_errors: true) + assert_template_result( + "Liquid error (line 1): Argument error in tag 'include' - Illegal template name", + "{% include nil %}", + render_errors: true, + ) end def test_render_raise_argument_error_when_template_is_not_a_string - assert_template_result("Liquid error (line 1): Argument error in tag 'include' - Illegal template name", - "{% include 123 %}", render_errors: true) + assert_template_result( + "Liquid error (line 1): Argument error in tag 'include' - Illegal template name", + "{% include 123 %}", + render_errors: true, + ) end def test_including_via_variable_value - assert_template_result("from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}", - partials: { "pick_a_source" => "from TestFileSystem" }) + assert_template_result( + "from TestFileSystem", + "{% assign page = 'pick_a_source' %}{% include page %}", + partials: { "pick_a_source" => "from TestFileSystem" }, + ) partials = { "product" => "Product: {{ product.title }} " } - assert_template_result("Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}", + assert_template_result( + "Product: Draft 151cm ", + "{% assign page = 'product' %}{% include page %}", { "product" => { 'title' => 'Draft 151cm' } }, - partials: partials) + partials: partials, + ) - assert_template_result("Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", + assert_template_result( + "Product: Draft 151cm ", + "{% assign page = 'product' %}{% include page for foo %}", { "foo" => { 'title' => 'Draft 151cm' } }, - partials: partials) + partials: partials, + ) end def test_including_with_strict_variables @@ -279,7 +350,10 @@ class IncludeTagTest < Minitest::Test def test_break_through_include assert_template_result("1", "{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}") - assert_template_result("1", "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}", - partials: { 'break' => "{% break %}" }) + assert_template_result( + "1", + "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}", + partials: { 'break' => "{% break %}" }, + ) end end # IncludeTagTest diff --git a/test/integration/tags/increment_tag_test.rb b/test/integration/tags/increment_tag_test.rb index 666d2d56..1ad94254 100644 --- a/test/integration/tags/increment_tag_test.rb +++ b/test/integration/tags/increment_tag_test.rb @@ -8,19 +8,23 @@ class IncrementTagTest < Minitest::Test def test_inc assert_template_result('0 1', '{%increment port %} {{ port }}') assert_template_result(' 0 1 2', '{{port}} {%increment port %} {%increment port%} {{port}}') - assert_template_result('0 0 1 2 1', + assert_template_result( + '0 0 1 2 1', '{%increment port %} {%increment starboard%} ' \ '{%increment port %} {%increment port%} ' \ - '{%increment starboard %}') + '{%increment starboard %}', + ) end def test_dec assert_template_result('-1 -1', '{%decrement port %} {{ port }}', { 'port' => 10 }) assert_template_result(' -1 -2 -2', '{{port}} {%decrement port %} {%decrement port%} {{port}}') - assert_template_result('0 1 2 0 3 1 1 3', + assert_template_result( + '0 1 2 0 3 1 1 3', '{%increment starboard %} {%increment starboard%} {%increment starboard%} ' \ '{%increment port %} {%increment starboard%} ' \ '{%increment port %} {%decrement port%} ' \ - '{%decrement starboard %}') + '{%decrement starboard %}', + ) end end diff --git a/test/integration/tags/raw_tag_test.rb b/test/integration/tags/raw_tag_test.rb index 6d395b5b..7e818129 100644 --- a/test/integration/tags/raw_tag_test.rb +++ b/test/integration/tags/raw_tag_test.rb @@ -6,8 +6,10 @@ class RawTagTest < Minitest::Test include Liquid def test_tag_in_raw - assert_template_result('{% comment %} test {% endcomment %}', - '{% raw %}{% comment %} test {% endcomment %}{% endraw %}') + assert_template_result( + '{% comment %} test {% endcomment %}', + '{% raw %}{% comment %} test {% endcomment %}{% endraw %}', + ) end def test_output_in_raw diff --git a/test/integration/tags/render_tag_test.rb b/test/integration/tags/render_tag_test.rb index 28dbb0de..f9ffc2f3 100644 --- a/test/integration/tags/render_tag_test.rb +++ b/test/integration/tags/render_tag_test.rb @@ -6,52 +6,79 @@ class RenderTagTest < Minitest::Test include Liquid def test_render_with_no_arguments - assert_template_result('rendered content', '{% render "source" %}', - partials: { 'source' => 'rendered content' }) + assert_template_result( + 'rendered content', + '{% render "source" %}', + partials: { 'source' => 'rendered content' }, + ) end def test_render_tag_looks_for_file_system_in_registers_first - assert_template_result('from register file system', '{% render "pick_a_source" %}', - partials: { 'pick_a_source' => 'from register file system' }) + assert_template_result( + 'from register file system', + '{% render "pick_a_source" %}', + partials: { 'pick_a_source' => 'from register file system' }, + ) end def test_render_passes_named_arguments_into_inner_scope - assert_template_result('My Product', '{% render "product", inner_product: outer_product %}', + assert_template_result( + 'My Product', + '{% render "product", inner_product: outer_product %}', { 'outer_product' => { 'title' => 'My Product' } }, - partials: { 'product' => '{{ inner_product.title }}' }) + partials: { 'product' => '{{ inner_product.title }}' }, + ) end def test_render_accepts_literals_as_arguments - assert_template_result('123', '{% render "snippet", price: 123 %}', - partials: { 'snippet' => '{{ price }}' }) + assert_template_result( + '123', + '{% render "snippet", price: 123 %}', + partials: { 'snippet' => '{{ price }}' }, + ) end def test_render_accepts_multiple_named_arguments - assert_template_result('1 2', '{% render "snippet", one: 1, two: 2 %}', - partials: { 'snippet' => '{{ one }} {{ two }}' }) + assert_template_result( + '1 2', + '{% render "snippet", one: 1, two: 2 %}', + partials: { 'snippet' => '{{ one }} {{ two }}' }, + ) end def test_render_does_not_inherit_parent_scope_variables - assert_template_result('', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}', - partials: { 'snippet' => '{{ outer_variable }}' }) + assert_template_result( + '', + '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}', + partials: { 'snippet' => '{{ outer_variable }}' }, + ) end def test_render_does_not_inherit_variable_with_same_name_as_snippet - assert_template_result('', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}", - partials: { 'snippet' => '{{ snippet }}' }) + assert_template_result( + '', + "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}", + partials: { 'snippet' => '{{ snippet }}' }, + ) end def test_render_does_not_mutate_parent_scope - assert_template_result('', "{% render 'snippet' %}{{ inner }}", - partials: { 'snippet' => '{% assign inner = 1 %}' }) + assert_template_result( + '', + "{% render 'snippet' %}{{ inner }}", + partials: { 'snippet' => '{% assign inner = 1 %}' }, + ) end def test_nested_render_tag - assert_template_result('one two', "{% render 'one' %}", + assert_template_result( + 'one two', + "{% render 'one' %}", partials: { 'one' => "one {% render 'two' %}", 'two' => 'two', - }) + }, + ) end def test_recursively_rendered_template_does_not_produce_endless_loop @@ -77,27 +104,36 @@ class RenderTagTest < Minitest::Test def test_include_tag_caches_second_read_of_same_partial file_system = StubFileSystem.new('snippet' => 'echo') - assert_equal('echoecho', + assert_equal( + 'echoecho', Template.parse('{% render "snippet" %}{% render "snippet" %}') - .render!({}, registers: { file_system: file_system })) + .render!({}, registers: { file_system: file_system }), + ) assert_equal(1, file_system.file_read_count) end def test_render_tag_doesnt_cache_partials_across_renders file_system = StubFileSystem.new('snippet' => 'my message') - assert_equal('my message', - Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system })) + assert_equal( + 'my message', + Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system }), + ) assert_equal(1, file_system.file_read_count) - assert_equal('my message', - Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system })) + assert_equal( + 'my message', + Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system }), + ) assert_equal(2, file_system.file_read_count) end def test_render_tag_within_if_statement - assert_template_result('my message', '{% if true %}{% render "snippet" %}{% endif %}', - partials: { 'snippet' => 'my message' }) + assert_template_result( + 'my message', + '{% if true %}{% render "snippet" %}{% endif %}', + partials: { 'snippet' => 'my message' }, + ) end def test_break_through_render @@ -107,13 +143,19 @@ class RenderTagTest < Minitest::Test end def test_increment_is_isolated_between_renders - assert_template_result('010', '{% increment %}{% increment %}{% render "incr" %}', - partials: { 'incr' => '{% increment %}' }) + assert_template_result( + '010', + '{% increment %}{% increment %}{% render "incr" %}', + partials: { 'incr' => '{% increment %}' }, + ) end def test_decrement_is_isolated_between_renders - assert_template_result('-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}', - partials: { 'decr' => '{% decrement %}' }) + assert_template_result( + '-1-2-1', + '{% decrement %}{% decrement %}{% render "decr" %}', + partials: { 'decr' => '{% decrement %}' }, + ) end def test_includes_will_not_render_inside_render_tag @@ -124,7 +166,7 @@ class RenderTagTest < Minitest::Test partials: { 'foo' => 'bar', 'test_include' => '{% include "foo" %}', - } + }, ) end @@ -138,72 +180,88 @@ class RenderTagTest < Minitest::Test 'nested_render_with_sibling_include' => '{% render "test_include" %}{% include "foo" %}', 'test_include' => '{% include "foo" %}', }, - render_errors: true + render_errors: true, ) end def test_render_tag_with - assert_template_result("Product: Draft 151cm ", + assert_template_result( + "Product: Draft 151cm ", "{% render 'product' with products[0] %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, partials: { 'product' => "Product: {{ product.title }} ", 'product_alias' => "Product: {{ product.title }} ", - }) + }, + ) end def test_render_tag_with_alias - assert_template_result("Product: Draft 151cm ", + assert_template_result( + "Product: Draft 151cm ", "{% render 'product_alias' with products[0] as product %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, partials: { 'product' => "Product: {{ product.title }} ", 'product_alias' => "Product: {{ product.title }} ", - }) + }, + ) end def test_render_tag_for_alias - assert_template_result("Product: Draft 151cm Product: Element 155cm ", + assert_template_result( + "Product: Draft 151cm Product: Element 155cm ", "{% render 'product_alias' for products as product %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, partials: { 'product' => "Product: {{ product.title }} ", 'product_alias' => "Product: {{ product.title }} ", - }) + }, + ) end def test_render_tag_for - assert_template_result("Product: Draft 151cm Product: Element 155cm ", + assert_template_result( + "Product: Draft 151cm Product: Element 155cm ", "{% render 'product' for products %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, partials: { 'product' => "Product: {{ product.title }} ", 'product_alias' => "Product: {{ product.title }} ", - }) + }, + ) end def test_render_tag_forloop - assert_template_result("Product: Draft 151cm first index:1 Product: Element 155cm last index:2 ", + assert_template_result( + "Product: Draft 151cm first index:1 Product: Element 155cm last index:2 ", "{% render 'product' for products %}", { "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }] }, partials: { 'product' => "Product: {{ product.title }} {% if forloop.first %}first{% endif %} {% if forloop.last %}last{% endif %} index:{{ forloop.index }} ", - }) + }, + ) end def test_render_tag_for_drop - assert_template_result("123", - "{% render 'loop' for loop as value %}", { "loop" => TestEnumerable.new }, + assert_template_result( + "123", + "{% render 'loop' for loop as value %}", + { "loop" => TestEnumerable.new }, partials: { 'loop' => "{{ value.foo }}", - }) + }, + ) end def test_render_tag_with_drop - assert_template_result("TestEnumerable", - "{% render 'loop' with loop as value %}", { "loop" => TestEnumerable.new }, + assert_template_result( + "TestEnumerable", + "{% render 'loop' with loop as value %}", + { "loop" => TestEnumerable.new }, partials: { 'loop' => "{{ value }}", - }) + }, + ) end end diff --git a/test/integration/tags/standard_tag_test.rb b/test/integration/tags/standard_tag_test.rb index 5ff425a4..6c297d40 100644 --- a/test/integration/tags/standard_tag_test.rb +++ b/test/integration/tags/standard_tag_test.rb @@ -6,8 +6,10 @@ class StandardTagTest < Minitest::Test include Liquid def test_no_transform - assert_template_result('this text should come out of the template without change...', - 'this text should come out of the template without change...') + assert_template_result( + 'this text should come out of the template without change...', + 'this text should come out of the template without change...', + ) assert_template_result('blah', 'blah') assert_template_result('', '') @@ -20,8 +22,10 @@ class StandardTagTest < Minitest::Test end def test_has_a_block_which_does_nothing - assert_template_result(%(the comment block should be removed .. right?), - %(the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?)) + assert_template_result( + %(the comment block should be removed .. right?), + %(the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?), + ) assert_template_result('', '{%comment%}{%endcomment%}') assert_template_result('', '{%comment%}{% endcomment %}') @@ -64,61 +68,81 @@ class StandardTagTest < Minitest::Test def test_capture assigns = { 'var' => 'content' } - assert_template_result('content foo content foo ', + assert_template_result( + 'content foo content foo ', '{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}', - assigns) + assigns, + ) end def test_capture_detects_bad_syntax assert_raises(SyntaxError) do - assert_template_result('content foo content foo ', + assert_template_result( + 'content foo content foo ', '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}', - { 'var' => 'content' }) + { 'var' => 'content' }, + ) end end def test_case assigns = { 'condition' => 2 } - assert_template_result(' its 2 ', + assert_template_result( + ' its 2 ', '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}', - assigns) + assigns, + ) assigns = { 'condition' => 1 } - assert_template_result(' its 1 ', + assert_template_result( + ' its 1 ', '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}', - assigns) + assigns, + ) assigns = { 'condition' => 3 } - assert_template_result('', + assert_template_result( + '', '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}', - assigns) + assigns, + ) assigns = { 'condition' => "string here" } - assert_template_result(' hit ', + assert_template_result( + ' hit ', '{% case condition %}{% when "string here" %} hit {% endcase %}', - assigns) + assigns, + ) assigns = { 'condition' => "bad string here" } - assert_template_result('', + assert_template_result( + '', '{% case condition %}{% when "string here" %} hit {% endcase %}',\ - assigns) + assigns, + ) end def test_case_with_else assigns = { 'condition' => 5 } - assert_template_result(' hit ', + assert_template_result( + ' hit ', '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}', - assigns) + assigns, + ) assigns = { 'condition' => 6 } - assert_template_result(' else ', + assert_template_result( + ' else ', '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}', - assigns) + assigns, + ) assigns = { 'condition' => 6 } - assert_template_result(' else ', + assert_template_result( + ' else ', '{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}', - assigns) + assigns, + ) end def test_case_on_size @@ -131,47 +155,67 @@ class StandardTagTest < Minitest::Test end def test_case_on_size_with_else - assert_template_result('else', + assert_template_result( + 'else', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', - { 'a' => [] }) + { 'a' => [] }, + ) - assert_template_result('1', + assert_template_result( + '1', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', - { 'a' => [1] }) + { 'a' => [1] }, + ) - assert_template_result('2', + assert_template_result( + '2', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', - { 'a' => [1, 1] }) + { 'a' => [1, 1] }, + ) - assert_template_result('else', + assert_template_result( + 'else', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', - { 'a' => [1, 1, 1] }) + { 'a' => [1, 1, 1] }, + ) - assert_template_result('else', + assert_template_result( + 'else', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', - { 'a' => [1, 1, 1, 1] }) + { 'a' => [1, 1, 1, 1] }, + ) - assert_template_result('else', + assert_template_result( + 'else', '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}', - { 'a' => [1, 1, 1, 1, 1] }) + { 'a' => [1, 1, 1, 1, 1] }, + ) end def test_case_on_length_with_else - assert_template_result('else', + assert_template_result( + 'else', '{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}', - {}) + {}, + ) - assert_template_result('false', + assert_template_result( + 'false', '{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}', - {}) + {}, + ) - assert_template_result('true', + assert_template_result( + 'true', '{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}', - {}) + {}, + ) - assert_template_result('else', + assert_template_result( + 'else', '{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}', - {}) + {}, + ) end def test_assign_from_case @@ -253,24 +297,33 @@ class StandardTagTest < Minitest::Test assert_template_result('one two one', '{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}') - assert_template_result('text-align: left text-align: right', - '{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}') + assert_template_result( + 'text-align: left text-align: right', + '{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}', + ) end def test_multiple_cycles - assert_template_result('1 2 1 1 2 3 1', - '{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}') + assert_template_result( + '1 2 1 1 2 3 1', + '{%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%} {%cycle 1,2,3%}', + ) end def test_multiple_named_cycles - assert_template_result('one one two two one one', - '{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}') + assert_template_result( + 'one one two two one one', + '{%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %} {%cycle 1: "one", "two" %} {%cycle 2: "one", "two" %}', + ) end def test_multiple_named_cycles_with_names_from_context assigns = { "var1" => 1, "var2" => 2 } - assert_template_result('one one two two one one', - '{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', assigns) + assert_template_result( + 'one one two two one one', + '{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', + assigns, + ) end def test_size_of_array diff --git a/test/integration/tags/table_row_test.rb b/test/integration/tags/table_row_test.rb index 5a7d1db2..24fd5344 100644 --- a/test/integration/tags/table_row_test.rb +++ b/test/integration/tags/table_row_test.rb @@ -18,52 +18,70 @@ class TableRowTest < Minitest::Test end def test_table_row - assert_template_result("\n 1 2 3 \n 4 5 6 \n", + assert_template_result( + "\n 1 2 3 \n 4 5 6 \n", '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}', - { 'numbers' => [1, 2, 3, 4, 5, 6] }) + { 'numbers' => [1, 2, 3, 4, 5, 6] }, + ) - assert_template_result("\n\n", + assert_template_result( + "\n\n", '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}', - { 'numbers' => [] }) + { 'numbers' => [] }, + ) end def test_table_row_with_different_cols - assert_template_result("\n 1 2 3 4 5 \n 6 \n", + assert_template_result( + "\n 1 2 3 4 5 \n 6 \n", '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}', - { 'numbers' => [1, 2, 3, 4, 5, 6] }) + { 'numbers' => [1, 2, 3, 4, 5, 6] }, + ) end def test_table_col_counter - assert_template_result("\n12\n12\n12\n", + assert_template_result( + "\n12\n12\n12\n", '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}', - { 'numbers' => [1, 2, 3, 4, 5, 6] }) + { 'numbers' => [1, 2, 3, 4, 5, 6] }, + ) end def test_quoted_fragment - assert_template_result("\n 1 2 3 \n 4 5 6 \n", + assert_template_result( + "\n 1 2 3 \n 4 5 6 \n", "{% tablerow n in collections.frontpage cols:3%} {{n}} {% endtablerow %}", - { 'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] } }) - assert_template_result("\n 1 2 3 \n 4 5 6 \n", + { 'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] } }, + ) + assert_template_result( + "\n 1 2 3 \n 4 5 6 \n", "{% tablerow n in collections['frontpage'] cols:3%} {{n}} {% endtablerow %}", - { 'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] } }) + { 'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] } }, + ) end def test_enumerable_drop - assert_template_result("\n 1 2 3 \n 4 5 6 \n", + assert_template_result( + "\n 1 2 3 \n 4 5 6 \n", '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}', - { 'numbers' => ArrayDrop.new([1, 2, 3, 4, 5, 6]) }) + { 'numbers' => ArrayDrop.new([1, 2, 3, 4, 5, 6]) }, + ) end def test_offset_and_limit - assert_template_result("\n 1 2 3 \n 4 5 6 \n", + assert_template_result( + "\n 1 2 3 \n 4 5 6 \n", '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}', - { 'numbers' => [0, 1, 2, 3, 4, 5, 6, 7] }) + { 'numbers' => [0, 1, 2, 3, 4, 5, 6, 7] }, + ) end def test_blank_string_not_iterable - assert_template_result("\n\n", + assert_template_result( + "\n\n", "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}", - { 'characters' => '' }) + { 'characters' => '' }, + ) end def test_cols_nil_constant_same_as_evaluated_nil_expression @@ -72,24 +90,32 @@ class TableRowTest < Minitest::Test "false" \ "\n" - assert_template_result(expect, - "{% tablerow i in (1..2) cols:nil %}{{ tablerowloop.col_last }}{% endtablerow %}") + assert_template_result( + expect, + "{% tablerow i in (1..2) cols:nil %}{{ tablerowloop.col_last }}{% endtablerow %}", + ) - assert_template_result(expect, + assert_template_result( + expect, "{% tablerow i in (1..2) cols:var %}{{ tablerowloop.col_last }}{% endtablerow %}", - { "var" => nil }) + { "var" => nil }, + ) end def test_nil_limit_is_treated_as_zero expect = "\n" \ "\n" - assert_template_result(expect, - "{% tablerow i in (1..2) limit:nil %}{{ i }}{% endtablerow %}") + assert_template_result( + expect, + "{% tablerow i in (1..2) limit:nil %}{{ i }}{% endtablerow %}", + ) - assert_template_result(expect, + assert_template_result( + expect, "{% tablerow i in (1..2) limit:var %}{{ i }}{% endtablerow %}", - { "var" => nil }) + { "var" => nil }, + ) end def test_nil_offset_is_treated_as_zero @@ -98,12 +124,16 @@ class TableRowTest < Minitest::Test "2:true" \ "\n" - assert_template_result(expect, - "{% tablerow i in (1..2) offset:nil %}{{ i }}:{{ tablerowloop.col_last }}{% endtablerow %}") + assert_template_result( + expect, + "{% tablerow i in (1..2) offset:nil %}{{ i }}:{{ tablerowloop.col_last }}{% endtablerow %}", + ) - assert_template_result(expect, + assert_template_result( + expect, "{% tablerow i in (1..2) offset:var %}{{ i }}:{{ tablerowloop.col_last }}{% endtablerow %}", - { "var" => nil }) + { "var" => nil }, + ) end def test_tablerow_loop_drop_attributes diff --git a/test/integration/tags/unless_else_tag_test.rb b/test/integration/tags/unless_else_tag_test.rb index 174fb790..0bbdb2b9 100644 --- a/test/integration/tags/unless_else_tag_test.rb +++ b/test/integration/tags/unless_else_tag_test.rb @@ -7,8 +7,10 @@ class UnlessElseTagTest < Minitest::Test def test_unless assert_template_result(' ', ' {% unless true %} this text should not go into the output {% endunless %} ') - assert_template_result(' this text should go into the output ', - ' {% unless false %} this text should go into the output {% endunless %} ') + assert_template_result( + ' this text should go into the output ', + ' {% unless false %} this text should go into the output {% endunless %} ', + ) assert_template_result(' you rock ?', '{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?') end diff --git a/test/integration/template_test.rb b/test/integration/template_test.rb index d3f63564..d2225489 100644 --- a/test/integration/template_test.rb +++ b/test/integration/template_test.rb @@ -93,10 +93,12 @@ class TemplateTest < Minitest::Test def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders t = Template.new - assigns = { 'number' => -> { - @global ||= 0 - @global += 1 - } } + assigns = { + 'number' => -> { + @global ||= 0 + @global += 1 + }, + } assert_equal('1', t.parse("{{number}}").render!(assigns)) assert_equal('1', t.parse("{{number}}").render!(assigns)) assert_equal('1', t.render!(assigns)) diff --git a/test/integration/variable_test.rb b/test/integration/variable_test.rb index a66f1a0b..42b38e33 100644 --- a/test/integration/variable_test.rb +++ b/test/integration/variable_test.rb @@ -145,7 +145,7 @@ class VariableTest < Minitest::Test 'list' => ['foo'], 'settings' => SettingsDrop.new("zero" => 0), 'foo' => 'bar', - } + }, ) assert_template_result( @@ -155,7 +155,7 @@ class VariableTest < Minitest::Test 'list' => [{ 'foo' => 'bar' }], 'settings' => SettingsDrop.new("zero" => 0), 'bar' => 'foo', - } + }, ) end @@ -167,7 +167,7 @@ class VariableTest < Minitest::Test 'list' => [1, { 'foo' => 'bar' }], 'settings' => SettingsDrop.new("zero" => 0), 'bar' => 'foo', - } + }, ) end diff --git a/test/unit/block_unit_test.rb b/test/unit/block_unit_test.rb index 42093ef1..81b79d85 100644 --- a/test/unit/block_unit_test.rb +++ b/test/unit/block_unit_test.rb @@ -35,8 +35,10 @@ class BlockUnitTest < Minitest::Test def test_variable_many_embedded_fragments template = Liquid::Template.parse(" {{funk}} {{so}} {{brother}} ") assert_equal(7, template.root.nodelist.size) - assert_equal([String, Variable, String, Variable, String, Variable, String], - block_types(template.root.nodelist)) + assert_equal( + [String, Variable, String, Variable, String, Variable, String], + block_types(template.root.nodelist), + ) end def test_with_block diff --git a/test/unit/condition_unit_test.rb b/test/unit/condition_unit_test.rb index 8fcc4510..d10cbb52 100644 --- a/test/unit/condition_unit_test.rb +++ b/test/unit/condition_unit_test.rb @@ -164,13 +164,17 @@ class ConditionUnitTest < Minitest::Test private def assert_evaluates_true(left, op, right) - assert(Condition.new(left, op, right).evaluate(@context), - "Evaluated false: #{left} #{op} #{right}") + assert( + Condition.new(left, op, right).evaluate(@context), + "Evaluated false: #{left} #{op} #{right}", + ) end def assert_evaluates_false(left, op, right) - assert(!Condition.new(left, op, right).evaluate(@context), - "Evaluated true: #{left} #{op} #{right}") + assert( + !Condition.new(left, op, right).evaluate(@context), + "Evaluated true: #{left} #{op} #{right}", + ) end def assert_evaluates_argument_error(left, op, right) diff --git a/test/unit/parse_tree_visitor_test.rb b/test/unit/parse_tree_visitor_test.rb index 71a902e1..6d946f22 100644 --- a/test/unit/parse_tree_visitor_test.rb +++ b/test/unit/parse_tree_visitor_test.rb @@ -8,245 +8,245 @@ class ParseTreeVisitorTest < Minitest::Test def test_variable assert_equal( ["test"], - visit(%({{ test }})) + visit(%({{ test }})), ) end def test_varible_with_filter assert_equal( ["test", "infilter"], - visit(%({{ test | split: infilter }})) + visit(%({{ test | split: infilter }})), ) end def test_dynamic_variable assert_equal( ["test", "inlookup"], - visit(%({{ test[inlookup] }})) + visit(%({{ test[inlookup] }})), ) end def test_echo assert_equal( ["test"], - visit(%({% echo test %})) + visit(%({% echo test %})), ) end def test_if_condition assert_equal( ["test"], - visit(%({% if test %}{% endif %})) + visit(%({% if test %}{% endif %})), ) end def test_complex_if_condition assert_equal( ["test"], - visit(%({% if 1 == 1 and 2 == test %}{% endif %})) + visit(%({% if 1 == 1 and 2 == test %}{% endif %})), ) end def test_if_body assert_equal( ["test"], - visit(%({% if 1 == 1 %}{{ test }}{% endif %})) + visit(%({% if 1 == 1 %}{{ test }}{% endif %})), ) end def test_unless_condition assert_equal( ["test"], - visit(%({% unless test %}{% endunless %})) + visit(%({% unless test %}{% endunless %})), ) end def test_complex_unless_condition assert_equal( ["test"], - visit(%({% unless 1 == 1 and 2 == test %}{% endunless %})) + visit(%({% unless 1 == 1 and 2 == test %}{% endunless %})), ) end def test_unless_body assert_equal( ["test"], - visit(%({% unless 1 == 1 %}{{ test }}{% endunless %})) + visit(%({% unless 1 == 1 %}{{ test }}{% endunless %})), ) end def test_elsif_condition assert_equal( ["test"], - visit(%({% if 1 == 1 %}{% elsif test %}{% endif %})) + visit(%({% if 1 == 1 %}{% elsif test %}{% endif %})), ) end def test_complex_elsif_condition assert_equal( ["test"], - visit(%({% if 1 == 1 %}{% elsif 1 == 1 and 2 == test %}{% endif %})) + visit(%({% if 1 == 1 %}{% elsif 1 == 1 and 2 == test %}{% endif %})), ) end def test_elsif_body assert_equal( ["test"], - visit(%({% if 1 == 1 %}{% elsif 2 == 2 %}{{ test }}{% endif %})) + visit(%({% if 1 == 1 %}{% elsif 2 == 2 %}{{ test }}{% endif %})), ) end def test_else_body assert_equal( ["test"], - visit(%({% if 1 == 1 %}{% else %}{{ test }}{% endif %})) + visit(%({% if 1 == 1 %}{% else %}{{ test }}{% endif %})), ) end def test_case_left assert_equal( ["test"], - visit(%({% case test %}{% endcase %})) + visit(%({% case test %}{% endcase %})), ) end def test_case_condition assert_equal( ["test"], - visit(%({% case 1 %}{% when test %}{% endcase %})) + visit(%({% case 1 %}{% when test %}{% endcase %})), ) end def test_case_when_body assert_equal( ["test"], - visit(%({% case 1 %}{% when 2 %}{{ test }}{% endcase %})) + visit(%({% case 1 %}{% when 2 %}{{ test }}{% endcase %})), ) end def test_case_else_body assert_equal( ["test"], - visit(%({% case 1 %}{% else %}{{ test }}{% endcase %})) + visit(%({% case 1 %}{% else %}{{ test }}{% endcase %})), ) end def test_for_in assert_equal( ["test"], - visit(%({% for x in test %}{% endfor %})) + visit(%({% for x in test %}{% endfor %})), ) end def test_for_limit assert_equal( ["test"], - visit(%({% for x in (1..5) limit: test %}{% endfor %})) + visit(%({% for x in (1..5) limit: test %}{% endfor %})), ) end def test_for_offset assert_equal( ["test"], - visit(%({% for x in (1..5) offset: test %}{% endfor %})) + visit(%({% for x in (1..5) offset: test %}{% endfor %})), ) end def test_for_body assert_equal( ["test"], - visit(%({% for x in (1..5) %}{{ test }}{% endfor %})) + visit(%({% for x in (1..5) %}{{ test }}{% endfor %})), ) end def test_for_range assert_equal( ["test"], - visit(%({% for x in (1..test) %}{% endfor %})) + visit(%({% for x in (1..test) %}{% endfor %})), ) end def test_tablerow_in assert_equal( ["test"], - visit(%({% tablerow x in test %}{% endtablerow %})) + visit(%({% tablerow x in test %}{% endtablerow %})), ) end def test_tablerow_limit assert_equal( ["test"], - visit(%({% tablerow x in (1..5) limit: test %}{% endtablerow %})) + visit(%({% tablerow x in (1..5) limit: test %}{% endtablerow %})), ) end def test_tablerow_offset assert_equal( ["test"], - visit(%({% tablerow x in (1..5) offset: test %}{% endtablerow %})) + visit(%({% tablerow x in (1..5) offset: test %}{% endtablerow %})), ) end def test_tablerow_body assert_equal( ["test"], - visit(%({% tablerow x in (1..5) %}{{ test }}{% endtablerow %})) + visit(%({% tablerow x in (1..5) %}{{ test }}{% endtablerow %})), ) end def test_cycle assert_equal( ["test"], - visit(%({% cycle test %})) + visit(%({% cycle test %})), ) end def test_assign assert_equal( ["test"], - visit(%({% assign x = test %})) + visit(%({% assign x = test %})), ) end def test_capture assert_equal( ["test"], - visit(%({% capture x %}{{ test }}{% endcapture %})) + visit(%({% capture x %}{{ test }}{% endcapture %})), ) end def test_include assert_equal( ["test"], - visit(%({% include test %})) + visit(%({% include test %})), ) end def test_include_with assert_equal( ["test"], - visit(%({% include "hai" with test %})) + visit(%({% include "hai" with test %})), ) end def test_include_for assert_equal( ["test"], - visit(%({% include "hai" for test %})) + visit(%({% include "hai" for test %})), ) end def test_render_with assert_equal( ["test"], - visit(%({% render "hai" with test %})) + visit(%({% render "hai" with test %})), ) end def test_render_for assert_equal( ["test"], - visit(%({% render "hai" for test %})) + visit(%({% render "hai" for test %})), ) end @@ -257,7 +257,7 @@ class ParseTreeVisitorTest < Minitest::Test ["test", []], ["xs", []], ]]], - traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit + traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit, ) end diff --git a/test/unit/partial_cache_unit_test.rb b/test/unit/partial_cache_unit_test.rb index b0a2483b..6bf8c5cd 100644 --- a/test/unit/partial_cache_unit_test.rb +++ b/test/unit/partial_cache_unit_test.rb @@ -7,13 +7,13 @@ class PartialCacheUnitTest < Minitest::Test context = Liquid::Context.build( registers: { file_system: StubFileSystem.new('my_partial' => 'my partial body'), - } + }, ) partial = Liquid::PartialCache.load( 'my_partial', context: context, - parse_context: Liquid::ParseContext.new + parse_context: Liquid::ParseContext.new, ) assert_equal('my partial body', partial.render) @@ -22,14 +22,14 @@ class PartialCacheUnitTest < Minitest::Test def test_reads_from_the_file_system_only_once_per_file file_system = StubFileSystem.new('my_partial' => 'some partial body') context = Liquid::Context.build( - registers: { file_system: file_system } + registers: { file_system: file_system }, ) 2.times do Liquid::PartialCache.load( 'my_partial', context: context, - parse_context: Liquid::ParseContext.new + parse_context: Liquid::ParseContext.new, ) end @@ -39,31 +39,31 @@ class PartialCacheUnitTest < Minitest::Test def test_cache_state_is_stored_per_context parse_context = Liquid::ParseContext.new shared_file_system = StubFileSystem.new( - 'my_partial' => 'my shared value' + 'my_partial' => 'my shared value', ) context_one = Liquid::Context.build( registers: { file_system: shared_file_system, - } + }, ) context_two = Liquid::Context.build( registers: { file_system: shared_file_system, - } + }, ) 2.times do Liquid::PartialCache.load( 'my_partial', context: context_one, - parse_context: parse_context + parse_context: parse_context, ) end Liquid::PartialCache.load( 'my_partial', context: context_two, - parse_context: parse_context + parse_context: parse_context, ) assert_equal(2, shared_file_system.file_read_count) @@ -72,18 +72,18 @@ class PartialCacheUnitTest < Minitest::Test def test_cache_is_not_broken_when_a_different_parse_context_is_used file_system = StubFileSystem.new('my_partial' => 'some partial body') context = Liquid::Context.build( - registers: { file_system: file_system } + registers: { file_system: file_system }, ) Liquid::PartialCache.load( 'my_partial', context: context, - parse_context: Liquid::ParseContext.new(my_key: 'value one') + parse_context: Liquid::ParseContext.new(my_key: 'value one'), ) Liquid::PartialCache.load( 'my_partial', context: context, - parse_context: Liquid::ParseContext.new(my_key: 'value two') + parse_context: Liquid::ParseContext.new(my_key: 'value two'), ) # Technically what we care about is that the file was parsed twice, @@ -95,13 +95,13 @@ class PartialCacheUnitTest < Minitest::Test context = Liquid::Context.build( registers: { file_system: StubFileSystem.new('my_partial' => 'my partial body'), - } + }, ) partial = Liquid::PartialCache.load( 'my_partial', context: context, - parse_context: Liquid::ParseContext.new + parse_context: Liquid::ParseContext.new, ) assert_equal('my partial body', partial.render) @@ -113,13 +113,13 @@ class PartialCacheUnitTest < Minitest::Test registers: { file_system: StubFileSystem.new('my_partial' => 'my partial body'), template_factory: template_factory, - } + }, ) partial = Liquid::PartialCache.load( 'my_partial', context: context, - parse_context: Liquid::ParseContext.new + parse_context: Liquid::ParseContext.new, ) assert_equal('my partial body', partial.render) @@ -129,12 +129,12 @@ class PartialCacheUnitTest < Minitest::Test def test_cache_state_is_shared_for_subcontexts parse_context = Liquid::ParseContext.new shared_file_system = StubFileSystem.new( - 'my_partial' => 'my shared value' + 'my_partial' => 'my shared value', ) context = Liquid::Context.build( registers: Liquid::Registers.new( file_system: shared_file_system, - ) + ), ) subcontext = context.new_isolated_subcontext @@ -144,13 +144,13 @@ class PartialCacheUnitTest < Minitest::Test Liquid::PartialCache.load( 'my_partial', context: context, - parse_context: parse_context + parse_context: parse_context, ) Liquid::PartialCache.load( 'my_partial', context: subcontext, - parse_context: parse_context + parse_context: parse_context, ) end diff --git a/test/unit/strainer_factory_unit_test.rb b/test/unit/strainer_factory_unit_test.rb index 43eafc1d..c78d422b 100644 --- a/test/unit/strainer_factory_unit_test.rb +++ b/test/unit/strainer_factory_unit_test.rb @@ -50,7 +50,7 @@ class StrainerFactoryUnitTest < Minitest::Test assert_match( /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/, - exception.message + exception.message, ) source = AccessScopeFilters.instance_method(:public_filter).source_location assert_equal(source.map(&:to_s), exception.backtrace[0].split(':')[0..1])