Update rubocop-shopify (2.7.0 -> 2.12.0) (#1687)

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

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)

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
 

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
 

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])