Rubocop fixes

* Disable rendering of tag based on register

* Improvements to disable tag

* Resolve disbale tag tests

* Test disable_tags register

* disabled_tags is now always avaiable

* Allow multiple tags to be disabled at once

* Move disabled check to block_body

* Code improvements

* Remove redundant nil check

* Improve disabled tag error output

* Improve disable tag API

* Code improvements

* Switch disabled? to not mutate output

* Fix array handling shortcut in disable_tags

lib/liquid.rb

@@ -78,8 +78,10 @@ require 'liquid/tokenizer'
 require 'liquid/parse_context'
 require 'liquid/partial_cache'
 require 'liquid/usage'
+require 'liquid/register'
 require 'liquid/static_registers'
 
 # Load all the tags of the standard library
 #
 Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+Dir["#{__dir__}/liquid/registers/*.rb"].each { |f| require f }

lib/liquid/block_body.rb

@@ -154,7 +154,13 @@ module Liquid
     private
 
     def render_node(context, output, node)
-      node.render_to_output_buffer(context, output)
+      if node.disabled?(context)
+        output << node.disabled_error_message
+        return
+      end
+      disable_tags(context, node.disabled_tags) do
+        node.render_to_output_buffer(context, output)
+      end
     rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
       context.handle_error(e, node.line_number)
     rescue ::StandardError => e
@@ -162,6 +168,11 @@ module Liquid
       output << context.handle_error(e, line_number)
     end
 
+    def disable_tags(context, tags, &block)
+      return yield if tags.empty?
+      context.registers[:disabled_tags].disable(tags, &block)
+    end
+
     def raise_if_resource_limits_reached(context, length)
       context.resource_limits.render_length += length
       return unless context.resource_limits.reached?

lib/liquid/locales/en.yml

@@ -25,3 +25,5 @@
       render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"
+    disabled:
+      tag: "usage is not allowed in this context"

lib/liquid/register.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Register
+  end
+end

lib/liquid/registers/disabled_tags.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Liquid
+  class DisabledTags < Register
+    def initialize
+      @disabled_tags = {}
+    end
+
+    def disabled?(tag)
+      @disabled_tags.key?(tag) && @disabled_tags[tag] > 0
+    end
+
+    def disable(tags)
+      tags.each(&method(:increment))
+      yield
+    ensure
+      tags.each(&method(:decrement))
+    end
+
+    private
+
+    def increment(tag)
+      @disabled_tags[tag] ||= 0
+      @disabled_tags[tag] += 1
+    end
+
+    def decrement(tag)
+      @disabled_tags[tag] -= 1
+    end
+  end
+
+  Template.add_register(:disabled_tags, DisabledTags.new)
+end

lib/liquid/tag.rb

@@ -13,7 +13,15 @@ module Liquid
         tag
       end
 
+      def disable_tags(*tags)
+        disabled_tags.push(*tags)
+      end
+
       private :new
+
+      def disabled_tags
+        @disabled_tags ||= []
+      end
     end
 
     def initialize(tag_name, markup, parse_context)
@@ -38,6 +46,14 @@ module Liquid
       ''
     end
 
+    def disabled?(context)
+      context.registers[:disabled_tags].disabled?(tag_name)
+    end
+
+    def disabled_error_message
+      "#{tag_name} #{options[:locale].t('errors.disabled.tag')}"
+    end
+
     # For backwards compatibility with custom tags. In a future release, the semantics
     # of the `render_to_output_buffer` method will become the default and the `render`
     # method will be removed.
@@ -49,5 +65,9 @@ module Liquid
     def blank?
       false
     end
+
+    def disabled_tags
+      self.class.disabled_tags
+    end
   end
 end

lib/liquid/tags/render.rb

@@ -4,6 +4,8 @@ module Liquid
   class Render < Tag
     SYNTAX = /(#{QuotedString})#{QuotedFragment}*/o
 
+    disable_tags "include"
+
     attr_reader :template_name_expr, :attributes
 
     def initialize(tag_name, markup, options)
@@ -22,6 +24,10 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
+      render_tag(context, output)
+    end
+
+    def render_tag(context, output)
       # Though we evaluate this here we will only ever parse it as a string literal.
       template_name = context.evaluate(@template_name_expr)
       raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name

lib/liquid/template.rb

@@ -92,6 +92,14 @@ module Liquid
         @tags ||= TagRegistry.new
       end
 
+      def add_register(name, klass)
+        registers[name.to_sym] = klass
+      end
+
+      def registers
+        @registers ||= {}
+      end
+
       def error_mode
         @error_mode ||= :lax
       end
@@ -191,18 +199,26 @@ module Liquid
 
       output = nil
 
+      context_register = context.registers.is_a?(StaticRegisters) ? context.registers.static : context.registers
+
       case args.last
       when Hash
         options = args.pop
         output = options[:output] if options[:output]
 
-        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
+        options[:registers]&.each do |key, register|
+          context_register[key] = register
+        end
 
         apply_options_to_context(context, options)
       when Module, Array
         context.add_filters(args.pop)
       end
 
+      Template.registers.each do |key, register|
+        context_register[key] = register
+      end
+
       # Retrying a render resets resource usage
       context.resource_limits.reset
 

lib/liquid/variable.rb

@@ -104,6 +104,14 @@ module Liquid
       output
     end
 
+    def disabled?(_context)
+      false
+    end
+
+    def disabled_tags
+      []
+    end
+
     private
 
     def parse_filter_expressions(filter_name, unparsed_args)

performance/memory_profile.rb

@@ -21,8 +21,8 @@ class Profiler
   end
 
   def profile(phase, &block)
-    print LOG_LABEL
-    print "#{phase}.. ".ljust(10)
+    print(LOG_LABEL)
+    print("#{phase}.. ".ljust(10))
     report = MemoryProfiler.report(&block)
     puts 'Done.'
     @headings  << phase.capitalize

performance/shopify/shop_filter.rb

@@ -31,7 +31,7 @@ module ShopFilter
 
   def link_to_vendor(vendor)
     if vendor
-      link_to vendor, url_for_vendor(vendor), vendor
+      link_to(vendor, url_for_vendor(vendor), vendor)
     else
       'Unknown Vendor'
     end
@@ -39,7 +39,7 @@ module ShopFilter
 
   def link_to_type(type)
     if type
-      link_to type, url_for_type(type), type
+      link_to(type, url_for_type(type), type)
     else
       'Unknown Vendor'
     end

test/integration/assign_test.rb

@@ -12,7 +12,7 @@ class AssignTest < Minitest::Test
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
+    assert_equal("Print this-thing", rendered.strip)
   end
 
   def test_assigned_variable

test/integration/blank_test.rb

@@ -96,9 +96,9 @@ class BlankTest < Minitest::Test
 
   def test_include_is_blank
     Liquid::Template.file_system = BlankTestFileSystem.new
-    assert_template_result "foobar" * (N + 1), wrap("{% include 'foobar' %}")
-    assert_template_result " foobar " * (N + 1), wrap("{% include ' foobar ' %}")
-    assert_template_result "   " * (N + 1), wrap(" {% include ' ' %} ")
+    assert_template_result("foobar" * (N + 1), wrap("{% include 'foobar' %}"))
+    assert_template_result(" foobar " * (N + 1), wrap("{% include ' foobar ' %}"))
+    assert_template_result("   " * (N + 1), wrap(" {% include ' ' %} "))
   end
 
   def test_case_is_blank

test/integration/block_test.rb

@@ -9,6 +9,6 @@ class BlockTest < Minitest::Test
     exc = assert_raises(SyntaxError) do
       Template.parse("{% if true %}{% endunless %}")
     end
-    assert_equal exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif"
+    assert_equal(exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif")
   end
 end

test/integration/capture_test.rb

@@ -16,7 +16,7 @@ class CaptureTest < Minitest::Test
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
+    assert_equal("Print this-thing", rendered.strip)
   end
 
   def test_capture_to_variable_from_outer_scope_if_existing
@@ -32,7 +32,7 @@ class CaptureTest < Minitest::Test
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal "test-string", rendered.gsub(/\s/, '')
+    assert_equal("test-string", rendered.gsub(/\s/, ''))
   end
 
   def test_assigning_from_capture
@@ -47,6 +47,6 @@ class CaptureTest < Minitest::Test
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal "3-3", rendered.gsub(/\s/, '')
+    assert_equal("3-3", rendered.gsub(/\s/, ''))
   end
 end # CaptureTest

test/integration/document_test.rb

@@ -9,13 +9,13 @@ class DocumentTest < Minitest::Test
     exc = assert_raises(SyntaxError) do
       Template.parse("{% else %}")
     end
-    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
+    assert_equal(exc.message, "Liquid syntax error: Unexpected outer 'else' tag")
   end
 
   def test_unknown_tag
     exc = assert_raises(SyntaxError) do
       Template.parse("{% foo %}")
     end
-    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
+    assert_equal(exc.message, "Liquid syntax error: Unknown tag 'foo'")
   end
 end

test/integration/drop_test.rb

@@ -111,7 +111,7 @@ class DropsTest < Minitest::Test
 
   def test_product_drop
     tpl = Liquid::Template.parse('  ')
-    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
+    assert_equal('  ', tpl.render!('product' => ProductDrop.new))
   end
 
   def test_rendering_raises_on_tainted_attr
@@ -141,52 +141,52 @@ class DropsTest < Minitest::Test
   end
 
   def test_drop_does_only_respond_to_whitelisted_methods
-    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
+    assert_equal("", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new))
+    assert_equal("", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new))
+    assert_equal("", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new))
+    assert_equal("", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new))
+    assert_equal("", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new))
+    assert_equal("", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new))
   end
 
   def test_drops_respond_to_to_liquid
-    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new)
-    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
+    assert_equal("text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new))
+    assert_equal("text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new))
   end
 
   def test_text_drop
     output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
-    assert_equal ' text1 ', output
+    assert_equal(' text1 ', output)
   end
 
   def test_catchall_unknown_method
     output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
-    assert_equal ' catchall_method: unknown ', output
+    assert_equal(' catchall_method: unknown ', output)
   end
 
   def test_catchall_integer_argument_drop
     output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
-    assert_equal ' catchall_method: 8 ', output
+    assert_equal(' catchall_method: 8 ', output)
   end
 
   def test_text_array_drop
     output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
-    assert_equal ' text1  text2 ', output
+    assert_equal(' text1  text2 ', output)
   end
 
   def test_context_drop
     output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
-    assert_equal ' carrot ', output
+    assert_equal(' carrot ', output)
   end
 
   def test_nested_context_drop
     output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
-    assert_equal ' monkey ', output
+    assert_equal(' monkey ', output)
   end
 
   def test_protected
     output = Liquid::Template.parse(' {{ product.callmenot }} ').render!('product' => ProductDrop.new)
-    assert_equal '  ', output
+    assert_equal('  ', output)
   end
 
   def test_object_methods_not_allowed
@@ -197,40 +197,40 @@ class DropsTest < Minitest::Test
   end
 
   def test_scope
-    assert_equal '1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new)
-    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal('1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new))
+    assert_equal('2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal('3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
   end
 
   def test_scope_though_proc
-    assert_equal '1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] })
-    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1])
+    assert_equal('1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }))
+    assert_equal('2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1]))
+    assert_equal('3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1]))
   end
 
   def test_scope_with_assigns
-    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
-    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
-    assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
+    assert_equal('variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new))
+    assert_equal('variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal('test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new))
+    assert_equal('test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new))
   end
 
   def test_scope_from_tags
-    assert_equal '1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal('1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal('12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal('123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
   end
 
   def test_access_context_from_drop
-    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3])
+    assert_equal('123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3]))
   end
 
   def test_enumerable_drop
-    assert_equal '123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
+    assert_equal('123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new))
   end
 
   def test_enumerable_drop_size
-    assert_equal '3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new)
+    assert_equal('3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new))
   end
 
   def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
@@ -250,7 +250,7 @@ class DropsTest < Minitest::Test
       assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
     end
 
-    assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)
+    assert_equal("yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new))
 
     [:min, :first].each do |method|
       assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
@@ -261,22 +261,22 @@ class DropsTest < Minitest::Test
   end
 
   def test_empty_string_value_access
-    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => '')
+    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => ''))
   end
 
   def test_nil_value_access
-    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil)
+    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil))
   end
 
   def test_default_to_s_on_drops
-    assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
-    assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
+    assert_equal('ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new))
+    assert_equal('EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new))
   end
 
   def test_invokable_methods
-    assert_equal %w(to_liquid catchall user_input context texts).to_set, ProductDrop.invokable_methods
-    assert_equal %w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods
-    assert_equal %w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods
-    assert_equal %w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods
+    assert_equal(%w(to_liquid catchall user_input context texts).to_set, ProductDrop.invokable_methods)
+    assert_equal(%w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods)
+    assert_equal(%w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods)
+    assert_equal(%w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods)
   end
 end # DropsTest

test/integration/error_handling_test.rb

@@ -35,31 +35,31 @@ class ErrorHandlingTest < Minitest::Test
     TEXT
 
     output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
-    assert_equal expected, output
+    assert_equal(expected, output)
   end
 
   def test_standard_error
     template = Liquid::Template.parse(' {{ errors.standard_error }} ')
-    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
+    assert_equal(' Liquid error: standard error ', template.render('errors' => ErrorDrop.new))
 
-    assert_equal 1, template.errors.size
-    assert_equal StandardError, template.errors.first.class
+    assert_equal(1, template.errors.size)
+    assert_equal(StandardError, template.errors.first.class)
   end
 
   def test_syntax
     template = Liquid::Template.parse(' {{ errors.syntax_error }} ')
-    assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
+    assert_equal(' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new))
 
-    assert_equal 1, template.errors.size
-    assert_equal SyntaxError, template.errors.first.class
+    assert_equal(1, template.errors.size)
+    assert_equal(SyntaxError, template.errors.first.class)
   end
 
   def test_argument
     template = Liquid::Template.parse(' {{ errors.argument_error }} ')
-    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+    assert_equal(' Liquid error: argument error ', template.render('errors' => ErrorDrop.new))
 
-    assert_equal 1, template.errors.size
-    assert_equal ArgumentError, template.errors.first.class
+    assert_equal(1, template.errors.size)
+    assert_equal(ArgumentError, template.errors.first.class)
   end
 
   def test_missing_endtag_parse_time_error
@@ -78,9 +78,9 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_lax_unrecognized_operator
     template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
-    assert_equal ' Liquid error: Unknown operator =! ', template.render
-    assert_equal 1, template.errors.size
-    assert_equal Liquid::ArgumentError, template.errors.first.class
+    assert_equal(' Liquid error: Unknown operator =! ', template.render)
+    assert_equal(1, template.errors.size)
+    assert_equal(Liquid::ArgumentError, template.errors.first.class)
   end
 
   def test_with_line_numbers_adds_numbers_to_parser_errors
@@ -124,8 +124,8 @@ class ErrorHandlingTest < Minitest::Test
       error_mode: :warn,
       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
@@ -141,7 +141,7 @@ class ErrorHandlingTest < Minitest::Test
         line_numbers: true)
     end
 
-    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
+    assert_equal('Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message)
   end
 
   def test_syntax_errors_in_nested_blocks_have_correct_line_number
@@ -158,37 +158,37 @@ class ErrorHandlingTest < Minitest::Test
         line_numbers: true)
     end
 
-    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
+    assert_equal("Liquid syntax error (line 5): Unknown tag 'foo'", err.message)
   end
 
   def test_strict_error_messages
     err = assert_raises(SyntaxError) do
       Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
     end
-    assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
+    assert_equal('Liquid syntax error: Unexpected character = in "1 =! 2"', err.message)
 
     err = assert_raises(SyntaxError) do
       Liquid::Template.parse('{{%%%}}', error_mode: :strict)
     end
-    assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
+    assert_equal('Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message)
   end
 
   def test_warnings
     template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
-    assert_equal 3, template.warnings.size
-    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
-    assert_equal '', template.render
+    assert_equal(3, template.warnings.size)
+    assert_equal('Unexpected character ~ in "~~~"', template.warnings[0].to_s(false))
+    assert_equal('Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false))
+    assert_equal('Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false))
+    assert_equal('', template.render)
   end
 
   def test_warning_line_numbers
     template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
-    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
-    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
-    assert_equal 3, template.warnings.size
-    assert_equal [1, 2, 3], template.warnings.map(&:line_number)
+    assert_equal('Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message)
+    assert_equal('Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message)
+    assert_equal('Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message)
+    assert_equal(3, template.warnings.size)
+    assert_equal([1, 2, 3], template.warnings.map(&:line_number))
   end
 
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
@@ -204,8 +204,8 @@ class ErrorHandlingTest < Minitest::Test
 
     output = template.render('errors' => ErrorDrop.new)
 
-    assert_equal 'This is a runtime error: Liquid error (line 1): internal', output
-    assert_equal [Liquid::InternalError], template.errors.map(&:class)
+    assert_equal('This is a runtime error: Liquid error (line 1): internal', output)
+    assert_equal([Liquid::InternalError], template.errors.map(&:class))
   end
 
   def test_setting_default_exception_renderer
@@ -219,8 +219,8 @@ class ErrorHandlingTest < Minitest::Test
 
     output = template.render('errors' => ErrorDrop.new)
 
-    assert_equal 'This is a runtime error: ', output
-    assert_equal [Liquid::ArgumentError], template.errors.map(&:class)
+    assert_equal('This is a runtime error: ', output)
+    assert_equal([Liquid::ArgumentError], template.errors.map(&:class))
   ensure
     Liquid::Template.default_exception_renderer = old_exception_renderer if old_exception_renderer
   end
@@ -235,10 +235,10 @@ class ErrorHandlingTest < Minitest::Test
 
     output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
 
-    assert_equal 'This is a runtime error: runtime error', output
-    assert_equal [Liquid::InternalError], exceptions.map(&:class)
-    assert_equal exceptions, template.errors
-    assert_equal '#<RuntimeError: runtime error>', exceptions.first.cause.inspect
+    assert_equal('This is a runtime error: runtime error', output)
+    assert_equal([Liquid::InternalError], exceptions.map(&:class))
+    assert_equal(exceptions, template.errors)
+    assert_equal('#<RuntimeError: runtime error>', exceptions.first.cause.inspect)
   end
 
   class TestFileSystem
@@ -257,7 +257,7 @@ class ErrorHandlingTest < Minitest::Test
     ensure
       Liquid::Template.file_system = old_file_system
     end
-    assert_equal "Argument error:\nLiquid error (product line 1): argument error", page
-    assert_equal "product", template.errors.first.template_name
+    assert_equal("Argument error:\nLiquid error (product line 1): argument error", page)
+    assert_equal("product", template.errors.first.template_name)
   end
 end

test/integration/filter_test.rb

@@ -41,13 +41,13 @@ class FiltersTest < Minitest::Test
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
 
-    assert_equal ' 1000$ ', Template.parse("{{var | money}}").render(@context)
+    assert_equal(' 1000$ ', Template.parse("{{var | money}}").render(@context))
   end
 
   def test_underscore_in_filter_name
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context)
+    assert_equal(' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context))
   end
 
   def test_second_filter_overwrites_first
@@ -55,20 +55,20 @@ class FiltersTest < Minitest::Test
     @context.add_filters(MoneyFilter)
     @context.add_filters(CanadianMoneyFilter)
 
-    assert_equal ' 1000$ CAD ', Template.parse("{{var | money}}").render(@context)
+    assert_equal(' 1000$ CAD ', Template.parse("{{var | money}}").render(@context))
   end
 
   def test_size
     @context['var'] = 'abcd'
     @context.add_filters(MoneyFilter)
 
-    assert_equal '4', Template.parse("{{var | size}}").render(@context)
+    assert_equal('4', Template.parse("{{var | size}}").render(@context))
   end
 
   def test_join
     @context['var'] = [1, 2, 3, 4]
 
-    assert_equal "1 2 3 4", Template.parse("{{var | join}}").render(@context)
+    assert_equal("1 2 3 4", Template.parse("{{var | join}}").render(@context))
   end
 
   def test_sort
@@ -78,11 +78,11 @@ class FiltersTest < Minitest::Test
     @context['arrays'] = ['flower', 'are']
     @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
 
-    assert_equal '1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context)
-    assert_equal 'alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context)
-    assert_equal '3', Template.parse("{{value | sort}}").render(@context)
-    assert_equal 'are flower', Template.parse("{{arrays | sort | join}}").render(@context)
-    assert_equal 'Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context)
+    assert_equal('1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context))
+    assert_equal('alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context))
+    assert_equal('3', Template.parse("{{value | sort}}").render(@context))
+    assert_equal('are flower', Template.parse("{{arrays | sort | join}}").render(@context))
+    assert_equal('Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context))
   end
 
   def test_sort_natural
@@ -91,13 +91,13 @@ class FiltersTest < Minitest::Test
     @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
 
     # Test strings
-    assert_equal 'Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context)
+    assert_equal('Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context))
 
     # Test hashes
-    assert_equal 'A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context)
+    assert_equal('A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context))
 
     # Test objects
-    assert_equal 'A b C', Template.parse("{{objects | sort_natural: 'a' | map: 'a' | join}}").render(@context)
+    assert_equal('A b C', Template.parse("{{objects | sort_natural: 'a' | map: 'a' | join}}").render(@context))
   end
 
   def test_compact
@@ -106,37 +106,37 @@ class FiltersTest < Minitest::Test
     @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
 
     # Test strings
-    assert_equal 'a b c', Template.parse("{{words | compact | join}}").render(@context)
+    assert_equal('a b c', Template.parse("{{words | compact | join}}").render(@context))
 
     # Test hashes
-    assert_equal 'A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context)
+    assert_equal('A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context))
 
     # Test objects
-    assert_equal 'A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context)
+    assert_equal('A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context))
   end
 
   def test_strip_html
     @context['var'] = "<b>bla blub</a>"
 
-    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
+    assert_equal("bla blub", Template.parse("{{ var | strip_html }}").render(@context))
   end
 
   def test_strip_html_ignore_comments_with_html
     @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
 
-    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
+    assert_equal("bla blub", Template.parse("{{ var | strip_html }}").render(@context))
   end
 
   def test_capitalize
     @context['var'] = "blub"
 
-    assert_equal "Blub", Template.parse("{{ var | capitalize }}").render(@context)
+    assert_equal("Blub", Template.parse("{{ var | capitalize }}").render(@context))
   end
 
   def test_nonexistent_filter_is_ignored
     @context['var'] = 1000
 
-    assert_equal '1000', Template.parse("{{ var | xyzzy }}").render(@context)
+    assert_equal('1000', Template.parse("{{ var | xyzzy }}").render(@context))
   end
 
   def test_filter_with_keyword_arguments
@@ -144,14 +144,14 @@ class FiltersTest < Minitest::Test
     @context['input'] = 'hello %{first_name}, %{last_name}'
     @context.add_filters(SubstituteFilter)
     output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
-    assert_equal 'hello john, doe', output
+    assert_equal('hello john, doe', output)
   end
 
   def test_override_object_method_in_filter
-    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
+    assert_equal("tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter]))
 
     # tap still treated as a non-existent filter
-    assert_equal "1000", Template.parse("{{var | tap}}").render!('var' => 1000)
+    assert_equal("1000", Template.parse("{{var | tap}}").render!('var' => 1000))
   end
 end
 
@@ -167,8 +167,8 @@ class FiltersInTemplate < Minitest::Test
   end
 
   def test_local_filter_with_deprecated_syntax
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
+    assert_equal(" 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter))
+    assert_equal(" 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter]))
   end
 end # FiltersTest
 

test/integration/output_test.rb

@@ -42,84 +42,84 @@ class OutputTest < Minitest::Test
     text = %( {{best_cars}} )
 
     expected = %( bmw )
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    assert_equal(expected, Template.parse(text).render!(@assigns))
   end
 
   def test_variable_traversing_with_two_brackets
     text = %({{ site.data.menu[include.menu][include.locale] }})
-    assert_equal "it works!", Template.parse(text).render!(
+    assert_equal("it works!", Template.parse(text).render!(
       "site" => { "data" => { "menu" => { "foo" => { "bar" => "it works!" } } } },
       "include" => { "menu" => "foo", "locale" => "bar" }
-    )
+    ))
   end
 
   def test_variable_traversing
     text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )
 
     expected = %( good bad good )
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    assert_equal(expected, Template.parse(text).render!(@assigns))
   end
 
   def test_variable_piping
     text = %( {{ car.gm | make_funny }} )
     expected = %( LOL )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_input
     text = %( {{ car.gm | cite_funny }} )
     expected = %( LOL: bad )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_args
     text = %! {{ car.gm | add_smiley : ':-(' }} !
     expected = %| bad :-( |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_no_args
     text = %( {{ car.gm | add_smiley }} )
     expected = %| bad :-) |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_multiple_variable_piping_with_args
     text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
     expected = %| bad :-( :-( |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_multiple_args
     text = %( {{ car.gm | add_tag : 'span', 'bar'}} )
     expected = %( <span id="bar">bad</span> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_variable_args
     text = %( {{ car.gm | add_tag : 'span', car.bmw}} )
     expected = %( <span id="good">bad</span> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_multiple_pipings
     text = %( {{ best_cars | cite_funny | paragraph }} )
     expected = %( <p>LOL: bmw</p> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_link_to
     text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
     expected = %( <a href="http://typo.leetsoft.com">Typo</a> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 end # OutputTest

test/integration/parsing_quirks_test.rb

@@ -7,7 +7,7 @@ class ParsingQuirksTest < Minitest::Test
 
   def test_parsing_css
     text = " div { font-weight: bold; } "
-    assert_equal text, Template.parse(text).render!
+    assert_equal(text, Template.parse(text).render!)
   end
 
   def test_raise_on_single_close_bracet
@@ -29,7 +29,7 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_error_on_empty_filter
-    assert Template.parse("{{test}}")
+    assert(Template.parse("{{test}}"))
 
     with_error_mode(:lax) do
       assert Template.parse("{{|test}}")
@@ -64,9 +64,9 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_no_error_on_lax_empty_filter
-    assert Template.parse("{{test |a|b|}}", error_mode: :lax)
-    assert Template.parse("{{test}}", error_mode: :lax)
-    assert Template.parse("{{|test|}}", error_mode: :lax)
+    assert(Template.parse("{{test |a|b|}}", error_mode: :lax))
+    assert(Template.parse("{{test}}", error_mode: :lax))
+    assert(Template.parse("{{|test|}}", error_mode: :lax))
   end
 
   def test_meaningless_parens_lax

test/integration/registers/disabled_tags_test.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DisabledTagsTest < Minitest::Test
+  include Liquid
+
+  class DisableRaw < Block
+    disable_tags "raw"
+  end
+
+  class DisableRawEcho < Block
+    disable_tags "raw", "echo"
+  end
+
+  def test_disables_raw
+    with_custom_tag('disable', DisableRaw) do
+      assert_template_result 'raw usage is not allowed in this contextfoo', '{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}'
+    end
+  end
+
+  def test_disables_echo_and_raw
+    with_custom_tag('disable', DisableRawEcho) do
+      assert_template_result 'raw usage is not allowed in this contextecho usage is not allowed in this context', '{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}'
+    end
+  end
+end

test/integration/render_profiling_test.rb

@@ -19,35 +19,35 @@ class RenderProfilingTest < Minitest::Test
     t = Template.parse("{{ 'a string' | upcase }}")
     t.render!
 
-    assert_nil t.profiler
+    assert_nil(t.profiler)
   end
 
   def test_parse_makes_available_simple_profiling
     t = Template.parse("{{ 'a string' | upcase }}", profile: true)
     t.render!
 
-    assert_equal 1, t.profiler.length
+    assert_equal(1, t.profiler.length)
 
     node = t.profiler[0]
-    assert_equal " 'a string' | upcase ", node.code
+    assert_equal(" 'a string' | upcase ", node.code)
   end
 
   def test_render_ignores_raw_strings_when_profiling
     t = Template.parse("This is raw string\nstuff\nNewline", profile: true)
     t.render!
 
-    assert_equal 0, t.profiler.length
+    assert_equal(0, t.profiler.length)
   end
 
   def test_profiling_includes_line_numbers_of_liquid_nodes
     t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
     t.render!
-    assert_equal 2, t.profiler.length
+    assert_equal(2, t.profiler.length)
 
     # {{ 'a string' | upcase }}
-    assert_equal 1, t.profiler[0].line_number
+    assert_equal(1, t.profiler[0].line_number)
     # {{ increment test }}
-    assert_equal 2, t.profiler[1].line_number
+    assert_equal(2, t.profiler[1].line_number)
   end
 
   def test_profiling_includes_line_numbers_of_included_partials
@@ -57,9 +57,9 @@ class RenderProfilingTest < Minitest::Test
     included_children = t.profiler[0].children
 
     # {% assign template_name = 'a_template' %}
-    assert_equal 1, included_children[0].line_number
+    assert_equal(1, included_children[0].line_number)
     # {{ template_name }}
-    assert_equal 2, included_children[1].line_number
+    assert_equal(2, included_children[1].line_number)
   end
 
   def test_profiling_times_the_rendering_of_tokens
@@ -67,14 +67,14 @@ class RenderProfilingTest < Minitest::Test
     t.render!
 
     node = t.profiler[0]
-    refute_nil node.render_time
+    refute_nil(node.render_time)
   end
 
   def test_profiling_times_the_entire_render
     t = Template.parse("{% include 'a_template' %}", profile: true)
     t.render!
 
-    assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
+    assert(t.profiler.total_render_time >= 0, "Total render time was not calculated")
   end
 
   def test_profiling_uses_include_to_mark_children
@@ -82,7 +82,7 @@ class RenderProfilingTest < Minitest::Test
     t.render!
 
     include_node = t.profiler[1]
-    assert_equal 2, include_node.children.length
+    assert_equal(2, include_node.children.length)
   end
 
   def test_profiling_marks_children_with_the_name_of_included_partial
@@ -134,23 +134,23 @@ class RenderProfilingTest < Minitest::Test
       timing_count += 1
     end
 
-    assert_equal 2, timing_count
+    assert_equal(2, timing_count)
   end
 
   def test_profiling_marks_children_of_if_blocks
     t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
     t.render!
 
-    assert_equal 1, t.profiler.length
-    assert_equal 2, t.profiler[0].children.length
+    assert_equal(1, t.profiler.length)
+    assert_equal(2, t.profiler[0].children.length)
   end
 
   def test_profiling_marks_children_of_for_blocks
     t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
     t.render!("collection" => ["one", "two"])
 
-    assert_equal 1, t.profiler.length
+    assert_equal(1, t.profiler.length)
     # Will profile each invocation of the for block
-    assert_equal 2, t.profiler[0].children.length
+    assert_equal(2, t.profiler[0].children.length)
   end
 end

test/integration/security_test.rb

@@ -19,28 +19,28 @@ class SecurityTest < Minitest::Test
     text = %( {{ '1+1' | instance_eval }} )
     expected = %( 1+1 )
 
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    assert_equal(expected, Template.parse(text).render!(@assigns))
   end
 
   def test_no_existing_instance_eval
     text = %( {{ '1+1' | __instance_eval__ }} )
     expected = %( 1+1 )
 
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    assert_equal(expected, Template.parse(text).render!(@assigns))
   end
 
   def test_no_instance_eval_after_mixing_in_new_filter
     text = %( {{ '1+1' | instance_eval }} )
     expected = %( 1+1 )
 
-    assert_equal expected, Template.parse(text).render!(@assigns)
+    assert_equal(expected, Template.parse(text).render!(@assigns))
   end
 
   def test_no_instance_eval_later_in_chain
     text = %( {{ '1+1' | add_one | instance_eval }} )
     expected = %( 1+1 + 1 )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, filters: SecurityFilter)
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: SecurityFilter))
   end
 
   def test_does_not_add_filters_to_symbol_table
@@ -49,27 +49,27 @@ class SecurityTest < Minitest::Test
     test = %( {{ "some_string" | a_bad_filter }} )
 
     template = Template.parse(test)
-    assert_equal [], (Symbol.all_symbols - current_symbols)
+    assert_equal([], (Symbol.all_symbols - current_symbols))
 
     template.render!
-    assert_equal [], (Symbol.all_symbols - current_symbols)
+    assert_equal([], (Symbol.all_symbols - current_symbols))
   end
 
   def test_does_not_add_drop_methods_to_symbol_table
     current_symbols = Symbol.all_symbols
 
     assigns = { 'drop' => Drop.new }
-    assert_equal "", Template.parse("{{ drop.custom_method_1 }}", assigns).render!
-    assert_equal "", Template.parse("{{ drop.custom_method_2 }}", assigns).render!
-    assert_equal "", Template.parse("{{ drop.custom_method_3 }}", assigns).render!
+    assert_equal("", Template.parse("{{ drop.custom_method_1 }}", assigns).render!)
+    assert_equal("", Template.parse("{{ drop.custom_method_2 }}", assigns).render!)
+    assert_equal("", Template.parse("{{ drop.custom_method_3 }}", assigns).render!)
 
-    assert_equal [], (Symbol.all_symbols - current_symbols)
+    assert_equal([], (Symbol.all_symbols - current_symbols))
   end
 
   def test_max_depth_nested_blocks_does_not_raise_exception
     depth = Liquid::Block::MAX_DEPTH
     code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
-    assert_equal "rendered", Template.parse(code).render!
+    assert_equal("rendered", Template.parse(code).render!)
   end
 
   def test_more_than_max_depth_nested_blocks_raises_exception

test/integration/standard_filter_test.rb

@@ -60,34 +60,34 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_size
-    assert_equal 3, @filters.size([1, 2, 3])
-    assert_equal 0, @filters.size([])
-    assert_equal 0, @filters.size(nil)
+    assert_equal(3, @filters.size([1, 2, 3]))
+    assert_equal(0, @filters.size([]))
+    assert_equal(0, @filters.size(nil))
   end
 
   def test_downcase
-    assert_equal 'testing', @filters.downcase("Testing")
-    assert_equal '', @filters.downcase(nil)
+    assert_equal('testing', @filters.downcase("Testing"))
+    assert_equal('', @filters.downcase(nil))
   end
 
   def test_upcase
-    assert_equal 'TESTING', @filters.upcase("Testing")
-    assert_equal '', @filters.upcase(nil)
+    assert_equal('TESTING', @filters.upcase("Testing"))
+    assert_equal('', @filters.upcase(nil))
   end
 
   def test_slice
-    assert_equal 'oob', @filters.slice('foobar', 1, 3)
-    assert_equal 'oobar', @filters.slice('foobar', 1, 1000)
-    assert_equal '', @filters.slice('foobar', 1, 0)
-    assert_equal 'o', @filters.slice('foobar', 1, 1)
-    assert_equal 'bar', @filters.slice('foobar', 3, 3)
-    assert_equal 'ar', @filters.slice('foobar', -2, 2)
-    assert_equal 'ar', @filters.slice('foobar', -2, 1000)
-    assert_equal 'r', @filters.slice('foobar', -1)
-    assert_equal '', @filters.slice(nil, 0)
-    assert_equal '', @filters.slice('foobar', 100, 10)
-    assert_equal '', @filters.slice('foobar', -100, 10)
-    assert_equal 'oob', @filters.slice('foobar', '1', '3')
+    assert_equal('oob', @filters.slice('foobar', 1, 3))
+    assert_equal('oobar', @filters.slice('foobar', 1, 1000))
+    assert_equal('', @filters.slice('foobar', 1, 0))
+    assert_equal('o', @filters.slice('foobar', 1, 1))
+    assert_equal('bar', @filters.slice('foobar', 3, 3))
+    assert_equal('ar', @filters.slice('foobar', -2, 2))
+    assert_equal('ar', @filters.slice('foobar', -2, 1000))
+    assert_equal('r', @filters.slice('foobar', -1))
+    assert_equal('', @filters.slice(nil, 0))
+    assert_equal('', @filters.slice('foobar', 100, 10))
+    assert_equal('', @filters.slice('foobar', -100, 10))
+    assert_equal('oob', @filters.slice('foobar', '1', '3'))
     assert_raises(Liquid::ArgumentError) do
       @filters.slice('foobar', nil)
     end
@@ -98,109 +98,112 @@ class StandardFiltersTest < Minitest::Test
 
   def test_slice_on_arrays
     input = 'foobar'.split(//)
-    assert_equal %w(o o b), @filters.slice(input, 1, 3)
-    assert_equal %w(o o b a r), @filters.slice(input, 1, 1000)
-    assert_equal %w(), @filters.slice(input, 1, 0)
-    assert_equal %w(o), @filters.slice(input, 1, 1)
-    assert_equal %w(b a r), @filters.slice(input, 3, 3)
-    assert_equal %w(a r), @filters.slice(input, -2, 2)
-    assert_equal %w(a r), @filters.slice(input, -2, 1000)
-    assert_equal %w(r), @filters.slice(input, -1)
-    assert_equal %w(), @filters.slice(input, 100, 10)
-    assert_equal %w(), @filters.slice(input, -100, 10)
+    assert_equal(%w(o o b), @filters.slice(input, 1, 3))
+    assert_equal(%w(o o b a r), @filters.slice(input, 1, 1000))
+    assert_equal(%w(), @filters.slice(input, 1, 0))
+    assert_equal(%w(o), @filters.slice(input, 1, 1))
+    assert_equal(%w(b a r), @filters.slice(input, 3, 3))
+    assert_equal(%w(a r), @filters.slice(input, -2, 2))
+    assert_equal(%w(a r), @filters.slice(input, -2, 1000))
+    assert_equal(%w(r), @filters.slice(input, -1))
+    assert_equal(%w(), @filters.slice(input, 100, 10))
+    assert_equal(%w(), @filters.slice(input, -100, 10))
   end
 
   def test_truncate
-    assert_equal '1234...', @filters.truncate('1234567890', 7)
-    assert_equal '1234567890', @filters.truncate('1234567890', 20)
-    assert_equal '...', @filters.truncate('1234567890', 0)
-    assert_equal '1234567890', @filters.truncate('1234567890')
-    assert_equal "测试...", @filters.truncate("测试测试测试测试", 5)
-    assert_equal '12341', @filters.truncate("1234567890", 5, 1)
+    assert_equal('1234...', @filters.truncate('1234567890', 7))
+    assert_equal('1234567890', @filters.truncate('1234567890', 20))
+    assert_equal('...', @filters.truncate('1234567890', 0))
+    assert_equal('1234567890', @filters.truncate('1234567890'))
+    assert_equal("测试...", @filters.truncate("测试测试测试测试", 5))
+    assert_equal('12341', @filters.truncate("1234567890", 5, 1))
   end
 
   def test_split
-    assert_equal ['12', '34'], @filters.split('12~34', '~')
-    assert_equal ['A? ', ' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
-    assert_equal ['A?Z'], @filters.split('A?Z', '~')
-    assert_equal [], @filters.split(nil, ' ')
-    assert_equal ['A', 'Z'], @filters.split('A1Z', 1)
+    assert_equal(['12', '34'], @filters.split('12~34', '~'))
+    assert_equal(['A? ', ' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~'))
+    assert_equal(['A?Z'], @filters.split('A?Z', '~'))
+    assert_equal([], @filters.split(nil, ' '))
+    assert_equal(['A', 'Z'], @filters.split('A1Z', 1))
   end
 
   def test_escape
-    assert_equal '&lt;strong&gt;', @filters.escape('<strong>')
-    assert_equal '1', @filters.escape(1)
-    assert_equal '2001-02-03', @filters.escape(Date.new(2001, 2, 3))
-    assert_nil @filters.escape(nil)
+    assert_equal('&lt;strong&gt;', @filters.escape('<strong>'))
+    assert_equal('1', @filters.escape(1))
+    assert_equal('2001-02-03', @filters.escape(Date.new(2001, 2, 3)))
+    assert_nil(@filters.escape(nil))
   end
 
   def test_h
-    assert_equal '&lt;strong&gt;', @filters.h('<strong>')
-    assert_equal '1', @filters.h(1)
-    assert_equal '2001-02-03', @filters.h(Date.new(2001, 2, 3))
-    assert_nil @filters.h(nil)
+    assert_equal('&lt;strong&gt;', @filters.h('<strong>'))
+    assert_equal('1', @filters.h(1))
+    assert_equal('2001-02-03', @filters.h(Date.new(2001, 2, 3)))
+    assert_nil(@filters.h(nil))
   end
 
   def test_escape_once
-    assert_equal '&lt;strong&gt;Hulk&lt;/strong&gt;', @filters.escape_once('&lt;strong&gt;Hulk</strong>')
+    assert_equal('&lt;strong&gt;Hulk&lt;/strong&gt;', @filters.escape_once('&lt;strong&gt;Hulk</strong>'))
   end
 
   def test_url_encode
-    assert_equal 'foo%2B1%40example.com', @filters.url_encode('foo+1@example.com')
-    assert_equal '1', @filters.url_encode(1)
-    assert_equal '2001-02-03', @filters.url_encode(Date.new(2001, 2, 3))
-    assert_nil @filters.url_encode(nil)
+    assert_equal('foo%2B1%40example.com', @filters.url_encode('foo+1@example.com'))
+    assert_equal('1', @filters.url_encode(1))
+    assert_equal('2001-02-03', @filters.url_encode(Date.new(2001, 2, 3)))
+    assert_nil(@filters.url_encode(nil))
   end
 
   def test_url_decode
-    assert_equal 'foo bar', @filters.url_decode('foo+bar')
-    assert_equal 'foo bar', @filters.url_decode('foo%20bar')
-    assert_equal 'foo+1@example.com', @filters.url_decode('foo%2B1%40example.com')
-    assert_equal '1', @filters.url_decode(1)
-    assert_equal '2001-02-03', @filters.url_decode(Date.new(2001, 2, 3))
-    assert_nil @filters.url_decode(nil)
+    assert_equal('foo bar', @filters.url_decode('foo+bar'))
+    assert_equal('foo bar', @filters.url_decode('foo%20bar'))
+    assert_equal('foo+1@example.com', @filters.url_decode('foo%2B1%40example.com'))
+    assert_equal('1', @filters.url_decode(1))
+    assert_equal('2001-02-03', @filters.url_decode(Date.new(2001, 2, 3)))
+    assert_nil(@filters.url_decode(nil))
     exception = assert_raises Liquid::ArgumentError do
       @filters.url_decode('%ff')
     end
-    assert_equal 'Liquid error: invalid byte sequence in UTF-8', exception.message
+    assert_equal('Liquid error: invalid byte sequence in UTF-8', exception.message)
   end
 
   def test_truncatewords
-    assert_equal 'one two three', @filters.truncatewords('one two three', 4)
-    assert_equal 'one two...', @filters.truncatewords('one two three', 2)
-    assert_equal 'one two three', @filters.truncatewords('one two three')
-    assert_equal 'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...', @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
-    assert_equal "测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5)
-    assert_equal 'one two1', @filters.truncatewords("one two three", 2, 1)
+    assert_equal('one two three', @filters.truncatewords('one two three', 4))
+    assert_equal('one two...', @filters.truncatewords('one two three', 2))
+    assert_equal('one two three', @filters.truncatewords('one two three'))
+    assert_equal(
+      'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...',
+        @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
+    )
+    assert_equal("测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5))
+    assert_equal('one two1', @filters.truncatewords("one two three", 2, 1))
   end
 
   def test_strip_html
-    assert_equal 'test', @filters.strip_html("<div>test</div>")
-    assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")
-    assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")
-    assert_equal '', @filters.strip_html("<style type='text/css'>foo bar</style>")
-    assert_equal 'test', @filters.strip_html("<div\nclass='multiline'>test</div>")
-    assert_equal 'test', @filters.strip_html("<!-- foo bar \n test -->test")
-    assert_equal '', @filters.strip_html(nil)
+    assert_equal('test', @filters.strip_html("<div>test</div>"))
+    assert_equal('test', @filters.strip_html("<div id='test'>test</div>"))
+    assert_equal('', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>"))
+    assert_equal('', @filters.strip_html("<style type='text/css'>foo bar</style>"))
+    assert_equal('test', @filters.strip_html("<div\nclass='multiline'>test</div>"))
+    assert_equal('test', @filters.strip_html("<!-- foo bar \n test -->test"))
+    assert_equal('', @filters.strip_html(nil))
 
     # Quirk of the existing implementation
-    assert_equal 'foo;', @filters.strip_html("<<<script </script>script>foo;</script>")
+    assert_equal('foo;', @filters.strip_html("<<<script </script>script>foo;</script>"))
   end
 
   def test_join
-    assert_equal '1 2 3 4', @filters.join([1, 2, 3, 4])
-    assert_equal '1 - 2 - 3 - 4', @filters.join([1, 2, 3, 4], ' - ')
-    assert_equal '1121314', @filters.join([1, 2, 3, 4], 1)
+    assert_equal('1 2 3 4', @filters.join([1, 2, 3, 4]))
+    assert_equal('1 - 2 - 3 - 4', @filters.join([1, 2, 3, 4], ' - '))
+    assert_equal('1121314', @filters.join([1, 2, 3, 4], 1))
   end
 
   def test_sort
-    assert_equal [1, 2, 3, 4], @filters.sort([4, 3, 2, 1])
-    assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], @filters.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
+    assert_equal([1, 2, 3, 4], @filters.sort([4, 3, 2, 1]))
+    assert_equal([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], @filters.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a"))
   end
 
   def test_sort_with_nils
-    assert_equal [1, 2, 3, 4, nil], @filters.sort([nil, 4, 3, 2, 1])
-    assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }, {}], @filters.sort([{ "a" => 4 }, { "a" => 3 }, {}, { "a" => 1 }, { "a" => 2 }], "a")
+    assert_equal([1, 2, 3, 4, nil], @filters.sort([nil, 4, 3, 2, 1]))
+    assert_equal([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }, {}], @filters.sort([{ "a" => 4 }, { "a" => 3 }, {}, { "a" => 1 }, { "a" => 2 }], "a"))
   end
 
   def test_sort_when_property_is_sometimes_missing_puts_nils_last
@@ -218,17 +221,17 @@ class StandardFiltersTest < Minitest::Test
       { "handle" => "delta" },
       { "handle" => "beta" },
     ]
-    assert_equal expectation, @filters.sort(input, "price")
+    assert_equal(expectation, @filters.sort(input, "price"))
   end
 
   def test_sort_natural
-    assert_equal ["a", "B", "c", "D"], @filters.sort_natural(["c", "D", "a", "B"])
-    assert_equal [{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, { "a" => "a" }, { "a" => "B" }], "a")
+    assert_equal(["a", "B", "c", "D"], @filters.sort_natural(["c", "D", "a", "B"]))
+    assert_equal([{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, { "a" => "a" }, { "a" => "B" }], "a"))
   end
 
   def test_sort_natural_with_nils
-    assert_equal ["a", "B", "c", "D", nil], @filters.sort_natural([nil, "c", "D", "a", "B"])
-    assert_equal [{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }, {}], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, {}, { "a" => "a" }, { "a" => "B" }], "a")
+    assert_equal(["a", "B", "c", "D", nil], @filters.sort_natural([nil, "c", "D", "a", "B"]))
+    assert_equal([{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }, {}], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, {}, { "a" => "a" }, { "a" => "B" }], "a"))
   end
 
   def test_sort_natural_when_property_is_sometimes_missing_puts_nils_last
@@ -246,7 +249,7 @@ class StandardFiltersTest < Minitest::Test
       { "handle" => "delta" },
       { "handle" => "beta" },
     ]
-    assert_equal expectation, @filters.sort_natural(input, "price")
+    assert_equal(expectation, @filters.sort_natural(input, "price"))
   end
 
   def test_sort_natural_case_check
@@ -268,12 +271,12 @@ class StandardFiltersTest < Minitest::Test
       { "key" => "Z" },
       { "fake" => "t" },
     ]
-    assert_equal expectation, @filters.sort_natural(input, "key")
-    assert_equal ["a", "b", "c", "X", "Y", "Z"], @filters.sort_natural(["X", "Y", "Z", "a", "b", "c"])
+    assert_equal(expectation, @filters.sort_natural(input, "key"))
+    assert_equal(["a", "b", "c", "X", "Y", "Z"], @filters.sort_natural(["X", "Y", "Z", "a", "b", "c"]))
   end
 
   def test_sort_empty_array
-    assert_equal [], @filters.sort([], "a")
+    assert_equal([], @filters.sort([], "a"))
   end
 
   def test_sort_invalid_property
@@ -289,7 +292,7 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_sort_natural_empty_array
-    assert_equal [], @filters.sort_natural([], "a")
+    assert_equal([], @filters.sort_natural([], "a"))
   end
 
   def test_sort_natural_invalid_property
@@ -305,26 +308,26 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_legacy_sort_hash
-    assert_equal [{ a: 1, b: 2 }], @filters.sort(a: 1, b: 2)
+    assert_equal([{ a: 1, b: 2 }], @filters.sort(a: 1, b: 2))
   end
 
   def test_numerical_vs_lexicographical_sort
-    assert_equal [2, 10], @filters.sort([10, 2])
-    assert_equal [{ "a" => 2 }, { "a" => 10 }], @filters.sort([{ "a" => 10 }, { "a" => 2 }], "a")
-    assert_equal ["10", "2"], @filters.sort(["10", "2"])
-    assert_equal [{ "a" => "10" }, { "a" => "2" }], @filters.sort([{ "a" => "10" }, { "a" => "2" }], "a")
+    assert_equal([2, 10], @filters.sort([10, 2]))
+    assert_equal([{ "a" => 2 }, { "a" => 10 }], @filters.sort([{ "a" => 10 }, { "a" => 2 }], "a"))
+    assert_equal(["10", "2"], @filters.sort(["10", "2"]))
+    assert_equal([{ "a" => "10" }, { "a" => "2" }], @filters.sort([{ "a" => "10" }, { "a" => "2" }], "a"))
   end
 
   def test_uniq
-    assert_equal ["foo"], @filters.uniq("foo")
-    assert_equal [1, 3, 2, 4], @filters.uniq([1, 1, 3, 2, 3, 1, 4, 3, 2, 1])
-    assert_equal [{ "a" => 1 }, { "a" => 3 }, { "a" => 2 }], @filters.uniq([{ "a" => 1 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
+    assert_equal(["foo"], @filters.uniq("foo"))
+    assert_equal([1, 3, 2, 4], @filters.uniq([1, 1, 3, 2, 3, 1, 4, 3, 2, 1]))
+    assert_equal([{ "a" => 1 }, { "a" => 3 }, { "a" => 2 }], @filters.uniq([{ "a" => 1 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a"))
     testdrop = TestDrop.new
-    assert_equal [testdrop], @filters.uniq([testdrop, TestDrop.new], 'test')
+    assert_equal([testdrop], @filters.uniq([testdrop, TestDrop.new], 'test'))
   end
 
   def test_uniq_empty_array
-    assert_equal [], @filters.uniq([], "a")
+    assert_equal([], @filters.uniq([], "a"))
   end
 
   def test_uniq_invalid_property
@@ -340,7 +343,7 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_compact_empty_array
-    assert_equal [], @filters.compact([], "a")
+    assert_equal([], @filters.compact([], "a"))
   end
 
   def test_compact_invalid_property
@@ -356,51 +359,51 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_reverse
-    assert_equal [4, 3, 2, 1], @filters.reverse([1, 2, 3, 4])
+    assert_equal([4, 3, 2, 1], @filters.reverse([1, 2, 3, 4]))
   end
 
   def test_legacy_reverse_hash
-    assert_equal [{ a: 1, b: 2 }], @filters.reverse(a: 1, b: 2)
+    assert_equal([{ a: 1, b: 2 }], @filters.reverse(a: 1, b: 2))
   end
 
   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_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' } }])
   end
 
   def test_map_doesnt_call_arbitrary_stuff
-    assert_template_result "", '{{ "foo" | map: "__id__" }}'
-    assert_template_result "", '{{ "foo" | map: "inspect" }}'
+    assert_template_result("", '{{ "foo" | map: "__id__" }}')
+    assert_template_result("", '{{ "foo" | map: "inspect" }}')
   end
 
   def test_map_calls_to_liquid
     t = TestThing.new
-    assert_template_result "woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t]
+    assert_template_result("woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t])
   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
     template = "{% assign key = 'foo' %}{{ thing | map: key | map: 'bar' }}"
     hash = { "foo" => { "bar" => 42 } }
-    assert_template_result "42", template, "thing" => hash
+    assert_template_result("42", template, "thing" => hash)
   end
 
   def test_sort_calls_to_liquid
     t = TestThing.new
     Liquid::Template.parse('{{ foo | sort: "whatever" }}').render("foo" => [t])
-    assert t.foo > 0
+    assert(t.foo > 0)
   end
 
   def test_map_over_proc
     drop = TestDrop.new
     p = proc { drop }
     templ = '{{ procs | map: "test" }}'
-    assert_template_result "testfoo", templ, "procs" => [p]
+    assert_template_result("testfoo", templ, "procs" => [p])
   end
 
   def test_map_over_drops_returning_procs
@@ -413,11 +416,11 @@ class StandardFiltersTest < Minitest::Test
       },
     ]
     templ = '{{ drops | map: "proc" }}'
-    assert_template_result "foobar", templ, "drops" => drops
+    assert_template_result("foobar", templ, "drops" => drops)
   end
 
   def test_map_works_on_enumerables
-    assert_template_result "123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new
+    assert_template_result("123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new)
   end
 
   def test_map_returns_empty_on_2d_input_array
@@ -444,42 +447,42 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_sort_works_on_enumerables
-    assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
+    assert_template_result("213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new)
   end
 
   def test_first_and_last_call_to_liquid
-    assert_template_result 'foobar', '{{ foo | first }}', 'foo' => [ThingWithToLiquid.new]
-    assert_template_result 'foobar', '{{ foo | last }}', 'foo' => [ThingWithToLiquid.new]
+    assert_template_result('foobar', '{{ foo | first }}', 'foo' => [ThingWithToLiquid.new])
+    assert_template_result('foobar', '{{ foo | last }}', 'foo' => [ThingWithToLiquid.new])
   end
 
   def test_truncate_calls_to_liquid
-    assert_template_result "wo...", '{{ foo | truncate: 5 }}', "foo" => TestThing.new
+    assert_template_result("wo...", '{{ foo | truncate: 5 }}', "foo" => TestThing.new)
   end
 
   def test_date
-    assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
-    assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
-    assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B")
+    assert_equal('May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B"))
+    assert_equal('June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B"))
+    assert_equal('July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B"))
 
-    assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B")
-    assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B")
-    assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B")
+    assert_equal('May', @filters.date("2006-05-05 10:00:00", "%B"))
+    assert_equal('June', @filters.date("2006-06-05 10:00:00", "%B"))
+    assert_equal('July', @filters.date("2006-07-05 10:00:00", "%B"))
 
-    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
-    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
-    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
-    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil)
+    assert_equal('2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", ""))
+    assert_equal('2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", ""))
+    assert_equal('2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", ""))
+    assert_equal('2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil))
 
-    assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")
+    assert_equal('07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y"))
 
-    assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
-    assert_equal Date.today.year.to_s, @filters.date('now', '%Y')
-    assert_equal Date.today.year.to_s, @filters.date('today', '%Y')
-    assert_equal Date.today.year.to_s, @filters.date('Today', '%Y')
+    assert_equal("07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y"))
+    assert_equal(Date.today.year.to_s, @filters.date('now', '%Y'))
+    assert_equal(Date.today.year.to_s, @filters.date('today', '%Y'))
+    assert_equal(Date.today.year.to_s, @filters.date('Today', '%Y'))
 
-    assert_nil @filters.date(nil, "%B")
+    assert_nil(@filters.date(nil, "%B"))
 
-    assert_equal '', @filters.date('', "%B")
+    assert_equal('', @filters.date('', "%B"))
 
     with_timezone("UTC") do
       assert_equal "07/05/2006", @filters.date(1152098955, "%m/%d/%Y")
@@ -488,169 +491,169 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_first_last
-    assert_equal 1, @filters.first([1, 2, 3])
-    assert_equal 3, @filters.last([1, 2, 3])
-    assert_nil @filters.first([])
-    assert_nil @filters.last([])
+    assert_equal(1, @filters.first([1, 2, 3]))
+    assert_equal(3, @filters.last([1, 2, 3]))
+    assert_nil(@filters.first([]))
+    assert_nil(@filters.last([]))
   end
 
   def test_replace
-    assert_equal '2 2 2 2', @filters.replace('1 1 1 1', '1', 2)
-    assert_equal '2 2 2 2', @filters.replace('1 1 1 1', 1, 2)
-    assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', '1', 2)
-    assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', 1, 2)
-    assert_template_result '2 1 1 1', "{{ '1 1 1 1' | replace_first: '1', 2 }}"
+    assert_equal('2 2 2 2', @filters.replace('1 1 1 1', '1', 2))
+    assert_equal('2 2 2 2', @filters.replace('1 1 1 1', 1, 2))
+    assert_equal('2 1 1 1', @filters.replace_first('1 1 1 1', '1', 2))
+    assert_equal('2 1 1 1', @filters.replace_first('1 1 1 1', 1, 2))
+    assert_template_result('2 1 1 1', "{{ '1 1 1 1' | replace_first: '1', 2 }}")
   end
 
   def test_remove
-    assert_equal '   ', @filters.remove("a a a a", 'a')
-    assert_equal '   ', @filters.remove("1 1 1 1", 1)
-    assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')
-    assert_equal ' 1 1 1', @filters.remove_first("1 1 1 1", 1)
-    assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}"
+    assert_equal('   ', @filters.remove("a a a a", 'a'))
+    assert_equal('   ', @filters.remove("1 1 1 1", 1))
+    assert_equal('a a a', @filters.remove_first("a a a a", 'a '))
+    assert_equal(' 1 1 1', @filters.remove_first("1 1 1 1", 1))
+    assert_template_result('a a a', "{{ 'a a a a' | remove_first: 'a ' }}")
   end
 
   def test_pipes_in_string_arguments
-    assert_template_result 'foobar', "{{ 'foo|bar' | remove: '|' }}"
+    assert_template_result('foobar', "{{ 'foo|bar' | remove: '|' }}")
   end
 
   def test_strip
-    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " ab c  "
-    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " \tab c  \n \t"
+    assert_template_result('ab c', "{{ source | strip }}", 'source' => " ab c  ")
+    assert_template_result('ab c', "{{ source | strip }}", 'source' => " \tab c  \n \t")
   end
 
   def test_lstrip
-    assert_template_result 'ab c  ', "{{ source | lstrip }}", 'source' => " ab c  "
-    assert_template_result "ab c  \n \t", "{{ source | lstrip }}", 'source' => " \tab c  \n \t"
+    assert_template_result('ab c  ', "{{ source | lstrip }}", 'source' => " ab c  ")
+    assert_template_result("ab c  \n \t", "{{ source | lstrip }}", 'source' => " \tab c  \n \t")
   end
 
   def test_rstrip
-    assert_template_result " ab c", "{{ source | rstrip }}", 'source' => " ab c  "
-    assert_template_result " \tab c", "{{ source | rstrip }}", 'source' => " \tab c  \n \t"
+    assert_template_result(" ab c", "{{ source | rstrip }}", 'source' => " ab c  ")
+    assert_template_result(" \tab c", "{{ source | rstrip }}", 'source' => " \tab c  \n \t")
   end
 
   def test_strip_newlines
-    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
-    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc"
+    assert_template_result('abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc")
+    assert_template_result('abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc")
   end
 
   def test_newlines_to_br
-    assert_template_result "a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc"
+    assert_template_result("a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc")
   end
 
   def test_plus
-    assert_template_result "2", "{{ 1 | plus:1 }}"
-    assert_template_result "2.0", "{{ '1' | plus:'1.0' }}"
+    assert_template_result("2", "{{ 1 | plus:1 }}")
+    assert_template_result("2.0", "{{ '1' | plus:'1.0' }}")
 
-    assert_template_result "5", "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3)
+    assert_template_result("5", "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3))
   end
 
   def test_minus
-    assert_template_result "4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1
-    assert_template_result "2.3", "{{ '4.3' | minus:'2' }}"
+    assert_template_result("4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1)
+    assert_template_result("2.3", "{{ '4.3' | minus:'2' }}")
 
-    assert_template_result "5", "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7)
+    assert_template_result("5", "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7))
   end
 
   def test_abs
-    assert_template_result "17", "{{ 17 | abs }}"
-    assert_template_result "17", "{{ -17 | abs }}"
-    assert_template_result "17", "{{ '17' | abs }}"
-    assert_template_result "17", "{{ '-17' | abs }}"
-    assert_template_result "0", "{{ 0 | abs }}"
-    assert_template_result "0", "{{ '0' | abs }}"
-    assert_template_result "17.42", "{{ 17.42 | abs }}"
-    assert_template_result "17.42", "{{ -17.42 | abs }}"
-    assert_template_result "17.42", "{{ '17.42' | abs }}"
-    assert_template_result "17.42", "{{ '-17.42' | abs }}"
+    assert_template_result("17", "{{ 17 | abs }}")
+    assert_template_result("17", "{{ -17 | abs }}")
+    assert_template_result("17", "{{ '17' | abs }}")
+    assert_template_result("17", "{{ '-17' | abs }}")
+    assert_template_result("0", "{{ 0 | abs }}")
+    assert_template_result("0", "{{ '0' | abs }}")
+    assert_template_result("17.42", "{{ 17.42 | abs }}")
+    assert_template_result("17.42", "{{ -17.42 | abs }}")
+    assert_template_result("17.42", "{{ '17.42' | abs }}")
+    assert_template_result("17.42", "{{ '-17.42' | abs }}")
   end
 
   def test_times
-    assert_template_result "12", "{{ 3 | times:4 }}"
-    assert_template_result "0", "{{ 'foo' | times:4 }}"
-    assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
-    assert_template_result "7.25", "{{ 0.0725 | times:100 }}"
-    assert_template_result "-7.25", '{{ "-0.0725" | times:100 }}'
-    assert_template_result "7.25", '{{ "-0.0725" | times: -100 }}'
-    assert_template_result "4", "{{ price | times:2 }}", 'price' => NumberLikeThing.new(2)
+    assert_template_result("12", "{{ 3 | times:4 }}")
+    assert_template_result("0", "{{ 'foo' | times:4 }}")
+    assert_template_result("6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}")
+    assert_template_result("7.25", "{{ 0.0725 | times:100 }}")
+    assert_template_result("-7.25", '{{ "-0.0725" | times:100 }}')
+    assert_template_result("7.25", '{{ "-0.0725" | times: -100 }}')
+    assert_template_result("4", "{{ price | times:2 }}", 'price' => NumberLikeThing.new(2))
   end
 
   def test_divided_by
-    assert_template_result "4", "{{ 12 | divided_by:3 }}"
-    assert_template_result "4", "{{ 14 | divided_by:3 }}"
+    assert_template_result("4", "{{ 12 | divided_by:3 }}")
+    assert_template_result("4", "{{ 14 | divided_by:3 }}")
 
-    assert_template_result "5", "{{ 15 | divided_by:3 }}"
-    assert_equal "Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render
+    assert_template_result("5", "{{ 15 | divided_by:3 }}")
+    assert_equal("Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render)
 
-    assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}"
+    assert_template_result("0.5", "{{ 2.0 | divided_by:4 }}")
     assert_raises(Liquid::ZeroDivisionError) do
       assert_template_result "4", "{{ 1 | modulo: 0 }}"
     end
 
-    assert_template_result "5", "{{ price | divided_by:2 }}", 'price' => NumberLikeThing.new(10)
+    assert_template_result("5", "{{ price | divided_by:2 }}", 'price' => NumberLikeThing.new(10))
   end
 
   def test_modulo
-    assert_template_result "1", "{{ 3 | modulo:2 }}"
+    assert_template_result("1", "{{ 3 | modulo:2 }}")
     assert_raises(Liquid::ZeroDivisionError) do
       assert_template_result "4", "{{ 1 | modulo: 0 }}"
     end
 
-    assert_template_result "1", "{{ price | modulo:2 }}", 'price' => NumberLikeThing.new(3)
+    assert_template_result("1", "{{ price | modulo:2 }}", 'price' => NumberLikeThing.new(3))
   end
 
   def test_round
-    assert_template_result "5", "{{ input | round }}", 'input' => 4.6
-    assert_template_result "4", "{{ '4.3' | round }}"
-    assert_template_result "4.56", "{{ input | round: 2 }}", 'input' => 4.5612
+    assert_template_result("5", "{{ input | round }}", 'input' => 4.6)
+    assert_template_result("4", "{{ '4.3' | round }}")
+    assert_template_result("4.56", "{{ input | round: 2 }}", 'input' => 4.5612)
     assert_raises(Liquid::FloatDomainError) do
       assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | round }}"
     end
 
-    assert_template_result "5", "{{ price | round }}", 'price' => NumberLikeThing.new(4.6)
-    assert_template_result "4", "{{ price | round }}", 'price' => NumberLikeThing.new(4.3)
+    assert_template_result("5", "{{ price | round }}", 'price' => NumberLikeThing.new(4.6))
+    assert_template_result("4", "{{ price | round }}", 'price' => NumberLikeThing.new(4.3))
   end
 
   def test_ceil
-    assert_template_result "5", "{{ input | ceil }}", 'input' => 4.6
-    assert_template_result "5", "{{ '4.3' | ceil }}"
+    assert_template_result("5", "{{ input | ceil }}", 'input' => 4.6)
+    assert_template_result("5", "{{ '4.3' | ceil }}")
     assert_raises(Liquid::FloatDomainError) do
       assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | ceil }}"
     end
 
-    assert_template_result "5", "{{ price | ceil }}", 'price' => NumberLikeThing.new(4.6)
+    assert_template_result("5", "{{ price | ceil }}", 'price' => NumberLikeThing.new(4.6))
   end
 
   def test_floor
-    assert_template_result "4", "{{ input | floor }}", 'input' => 4.6
-    assert_template_result "4", "{{ '4.3' | floor }}"
+    assert_template_result("4", "{{ input | floor }}", 'input' => 4.6)
+    assert_template_result("4", "{{ '4.3' | floor }}")
     assert_raises(Liquid::FloatDomainError) do
       assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | floor }}"
     end
 
-    assert_template_result "5", "{{ price | floor }}", 'price' => NumberLikeThing.new(5.4)
+    assert_template_result("5", "{{ price | floor }}", 'price' => NumberLikeThing.new(5.4))
   end
 
   def test_at_most
-    assert_template_result "4", "{{ 5 | at_most:4 }}"
-    assert_template_result "5", "{{ 5 | at_most:5 }}"
-    assert_template_result "5", "{{ 5 | at_most:6 }}"
+    assert_template_result("4", "{{ 5 | at_most:4 }}")
+    assert_template_result("5", "{{ 5 | at_most:5 }}")
+    assert_template_result("5", "{{ 5 | at_most:6 }}")
 
-    assert_template_result "4.5", "{{ 4.5 | at_most:5 }}"
-    assert_template_result "5", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(6)
-    assert_template_result "4", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(4)
-    assert_template_result "4", "{{ 5 | at_most: width }}", 'width' => NumberLikeThing.new(4)
+    assert_template_result("4.5", "{{ 4.5 | at_most:5 }}")
+    assert_template_result("5", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(6))
+    assert_template_result("4", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(4))
+    assert_template_result("4", "{{ 5 | at_most: width }}", 'width' => NumberLikeThing.new(4))
   end
 
   def test_at_least
-    assert_template_result "5", "{{ 5 | at_least:4 }}"
-    assert_template_result "5", "{{ 5 | at_least:5 }}"
-    assert_template_result "6", "{{ 5 | at_least:6 }}"
+    assert_template_result("5", "{{ 5 | at_least:4 }}")
+    assert_template_result("5", "{{ 5 | at_least:5 }}")
+    assert_template_result("6", "{{ 5 | at_least:6 }}")
 
-    assert_template_result "5", "{{ 4.5 | at_least:5 }}"
-    assert_template_result "6", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(6)
-    assert_template_result "5", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(4)
-    assert_template_result "6", "{{ 5 | at_least: width }}", 'width' => NumberLikeThing.new(6)
+    assert_template_result("5", "{{ 4.5 | at_least:5 }}")
+    assert_template_result("6", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(6))
+    assert_template_result("5", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(4))
+    assert_template_result("6", "{{ 5 | at_least: width }}", 'width' => NumberLikeThing.new(6))
   end
 
   def test_append
@@ -660,9 +663,9 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_concat
-    assert_equal [1, 2, 3, 4], @filters.concat([1, 2], [3, 4])
-    assert_equal [1, 2, 'a'],  @filters.concat([1, 2], ['a'])
-    assert_equal [1, 2, 10],   @filters.concat([1, 2], [10])
+    assert_equal([1, 2, 3, 4], @filters.concat([1, 2], [3, 4]))
+    assert_equal([1, 2, 'a'],  @filters.concat([1, 2], ['a']))
+    assert_equal([1, 2, 10],   @filters.concat([1, 2], [10]))
 
     assert_raises(Liquid::ArgumentError, "concat filter requires an array argument") do
       @filters.concat([1, 2], 10)
@@ -676,12 +679,12 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_default
-    assert_equal "foo", @filters.default("foo", "bar")
-    assert_equal "bar", @filters.default(nil, "bar")
-    assert_equal "bar", @filters.default("", "bar")
-    assert_equal "bar", @filters.default(false, "bar")
-    assert_equal "bar", @filters.default([], "bar")
-    assert_equal "bar", @filters.default({}, "bar")
+    assert_equal("foo", @filters.default("foo", "bar"))
+    assert_equal("bar", @filters.default(nil, "bar"))
+    assert_equal("bar", @filters.default("", "bar"))
+    assert_equal("bar", @filters.default(false, "bar"))
+    assert_equal("bar", @filters.default([], "bar"))
+    assert_equal("bar", @filters.default({}, "bar"))
   end
 
   def test_cannot_access_private_methods
@@ -706,8 +709,8 @@ class StandardFiltersTest < Minitest::Test
       { "handle" => "delta", "ok" => true },
     ]
 
-    assert_equal expectation, @filters.where(input, "ok", true)
-    assert_equal expectation, @filters.where(input, "ok")
+    assert_equal(expectation, @filters.where(input, "ok", true))
+    assert_equal(expectation, @filters.where(input, "ok"))
   end
 
   def test_where_no_key_set
@@ -723,13 +726,13 @@ class StandardFiltersTest < Minitest::Test
       { "handle" => "delta", "ok" => true },
     ]
 
-    assert_equal expectation, @filters.where(input, "ok", true)
-    assert_equal expectation, @filters.where(input, "ok")
+    assert_equal(expectation, @filters.where(input, "ok", true))
+    assert_equal(expectation, @filters.where(input, "ok"))
   end
 
   def test_where_non_array_map_input
-    assert_equal [{ "a" => "ok" }], @filters.where({ "a" => "ok" }, "a", "ok")
-    assert_equal [], @filters.where({ "a" => "not ok" }, "a", "ok")
+    assert_equal([{ "a" => "ok" }], @filters.where({ "a" => "ok" }, "a", "ok"))
+    assert_equal([], @filters.where({ "a" => "not ok" }, "a", "ok"))
   end
 
   def test_where_indexable_but_non_map_value
@@ -744,14 +747,14 @@ class StandardFiltersTest < Minitest::Test
       { "message" => "Hallo!", "language" => "German" },
     ]
 
-    assert_equal [{ "message" => "Bonjour!", "language" => "French" }], @filters.where(input, "language", "French")
-    assert_equal [{ "message" => "Hallo!", "language" => "German" }], @filters.where(input, "language", "German")
-    assert_equal [{ "message" => "Hello!", "language" => "English" }], @filters.where(input, "language", "English")
+    assert_equal([{ "message" => "Bonjour!", "language" => "French" }], @filters.where(input, "language", "French"))
+    assert_equal([{ "message" => "Hallo!", "language" => "German" }], @filters.where(input, "language", "German"))
+    assert_equal([{ "message" => "Hello!", "language" => "English" }], @filters.where(input, "language", "English"))
   end
 
   def test_where_array_of_only_unindexable_values
-    assert_nil @filters.where([nil], "ok", true)
-    assert_nil @filters.where([nil], "ok")
+    assert_nil(@filters.where([nil], "ok", true))
+    assert_nil(@filters.where([nil], "ok"))
   end
 
   def test_where_no_target_value
@@ -762,7 +765,7 @@ class StandardFiltersTest < Minitest::Test
       { "bar" => true },
     ]
 
-    assert_equal [{ "foo" => true }, { "foo" => "for sure" }], @filters.where(input, "foo")
+    assert_equal([{ "foo" => true }, { "foo" => "for sure" }], @filters.where(input, "foo"))
   end
 
   private

test/integration/tags/for_tag_test.rb

@@ -350,7 +350,7 @@ HERE
   end
 
   def test_inner_for_over_empty_input
-    assert_template_result 'oo', '{% for a in (1..2) %}o{% for b in empty %}{% endfor %}{% endfor %}'
+    assert_template_result('oo', '{% for a in (1..2) %}o{% for b in empty %}{% endfor %}{% endfor %}')
   end
 
   def test_blank_string_not_iterable
@@ -394,8 +394,8 @@ HERE
     expected = '12345'
     template = '{% for item in items %}{{item}}{% endfor %}'
     assert_template_result(expected, template, assigns)
-    assert loader.each_called
-    assert !loader.load_slice_called
+    assert(loader.each_called)
+    assert(!loader.load_slice_called)
   end
 
   def test_iterate_with_load_slice_when_limit_applied
@@ -404,8 +404,8 @@ HERE
     expected = '1'
     template = '{% for item in items limit:1 %}{{item}}{% endfor %}'
     assert_template_result(expected, template, assigns)
-    assert !loader.each_called
-    assert loader.load_slice_called
+    assert(!loader.each_called)
+    assert(loader.load_slice_called)
   end
 
   def test_iterate_with_load_slice_when_limit_and_offset_applied
@@ -414,8 +414,8 @@ HERE
     expected = '34'
     template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
     assert_template_result(expected, template, assigns)
-    assert !loader.each_called
-    assert loader.load_slice_called
+    assert(!loader.each_called)
+    assert(loader.load_slice_called)
   end
 
   def test_iterate_with_load_slice_returns_same_results_as_without
@@ -435,6 +435,6 @@ HERE
       Liquid::Template.parse('{% for i in (1..2) %}{{ standard_error }}{% endfor %}').render!(context)
     end
 
-    assert context.registers[:for_stack].empty?
+    assert(context.registers[:for_stack].empty?)
   end
 end

test/integration/tags/include_tag_test.rb

@@ -82,56 +82,56 @@ 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 ",
-      "{% include 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }]
+    assert_template_result("Product: Draft 151cm ",
+      "{% include 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_include_tag_with_default_name
-    assert_template_result "Product: Draft 151cm ",
-      "{% include 'product' %}", "product" => { 'title' => 'Draft 151cm' }
+    assert_template_result("Product: Draft 151cm ",
+      "{% include 'product' %}", "product" => { 'title' => 'Draft 151cm' })
   end
 
   def test_include_tag_for
-    assert_template_result "Product: Draft 151cm Product: Element 155cm ",
-      "{% include 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }]
+    assert_template_result("Product: Draft 151cm Product: Element 155cm ",
+      "{% include 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
   end
 
   def test_include_tag_with_local_variables
-    assert_template_result "Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}"
+    assert_template_result("Locale: test123 ", "{% include 'locale_variables' echo1: 'test123' %}")
   end
 
   def test_include_tag_with_multiple_local_variables
-    assert_template_result "Locale: test123 test321",
-      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}"
+    assert_template_result("Locale: test123 test321",
+      "{% include 'locale_variables' echo1: 'test123', echo2: 'test321' %}")
   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' }
+      'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' })
   end
 
   def test_included_templates_assigns_variables
-    assert_template_result "bar", "{% include 'assignments' %}{{ foo }}"
+    assert_template_result("bar", "{% include 'assignments' %}{{ foo }}")
   end
 
   def test_nested_include_tag
-    assert_template_result "body body_detail", "{% include 'body' %}"
+    assert_template_result("body body_detail", "{% include 'body' %}")
 
-    assert_template_result "header body body_detail footer", "{% include 'nested_template' %}"
+    assert_template_result("header body body_detail footer", "{% include 'nested_template' %}")
   end
 
   def test_nested_include_with_variable
-    assert_template_result "Product: Draft 151cm details ",
-      "{% include 'nested_product_template' with product %}", "product" => { "title" => 'Draft 151cm' }
+    assert_template_result("Product: Draft 151cm details ",
+      "{% include 'nested_product_template' with product %}", "product" => { "title" => 'Draft 151cm' })
 
-    assert_template_result "Product: Draft 151cm details Product: Element 155cm details ",
-      "{% include 'nested_product_template' for products %}", "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }]
+    assert_template_result("Product: Draft 151cm details Product: Element 155cm details ",
+      "{% include 'nested_product_template' for products %}", "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }])
   end
 
   def test_recursively_included_template_does_not_produce_endless_loop
@@ -149,41 +149,41 @@ class IncludeTagTest < Minitest::Test
   end
 
   def test_dynamically_choosen_template
-    assert_template_result "Test123", "{% include template %}", "template" => 'Test123'
-    assert_template_result "Test321", "{% include template %}", "template" => 'Test321'
+    assert_template_result("Test123", "{% include template %}", "template" => 'Test123')
+    assert_template_result("Test321", "{% include template %}", "template" => 'Test321')
 
-    assert_template_result "Product: Draft 151cm ", "{% include template for product %}",
-      "template" => 'product', 'product' => { 'title' => 'Draft 151cm' }
+    assert_template_result("Product: Draft 151cm ", "{% include template for product %}",
+      "template" => 'product', 'product' => { 'title' => 'Draft 151cm' })
   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 1, file_system.count
+    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 1, file_system.count
+    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 2, file_system.count
+    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 %}"
+    assert_template_result("foo_if_true", "{% if true %}{% include 'foo_if_true' %}{% endif %}")
   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
@@ -193,8 +193,8 @@ 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
@@ -205,7 +205,7 @@ class IncludeTagTest < Minitest::Test
 
     a = Liquid::Template.parse(' {% include "nested_template" %}')
     a.render!
-    assert_empty a.errors
+    assert_empty(a.errors)
   end
 
   def test_passing_options_to_included_templates
@@ -235,22 +235,22 @@ class IncludeTagTest < Minitest::Test
   end
 
   def test_including_via_variable_value
-    assert_template_result "from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}"
+    assert_template_result("from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}")
 
-    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}", "product" => { 'title' => 'Draft 151cm' }
+    assert_template_result("Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}", "product" => { 'title' => 'Draft 151cm' })
 
-    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' }
+    assert_template_result("Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' })
   end
 
   def test_including_with_strict_variables
     template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn)
     template.render(nil, strict_variables: true)
 
-    assert_equal [], template.errors
+    assert_equal([], template.errors)
   end
 
   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 %}"
+    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 %}")
   end
 end # IncludeTagTest

test/integration/tags/raw_tag_test.rb

@@ -6,23 +6,23 @@ 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
-    assert_template_result '{{ test }}', '{% raw %}{{ test }}{% endraw %}'
+    assert_template_result('{{ test }}', '{% raw %}{{ test }}{% endraw %}')
   end
 
   def test_open_tag_in_raw
-    assert_template_result ' Foobar {% invalid ', '{% raw %} Foobar {% invalid {% endraw %}'
-    assert_template_result ' Foobar invalid %} ', '{% raw %} Foobar invalid %} {% endraw %}'
-    assert_template_result ' Foobar {{ invalid ', '{% raw %} Foobar {{ invalid {% endraw %}'
-    assert_template_result ' Foobar invalid }} ', '{% raw %} Foobar invalid }} {% endraw %}'
-    assert_template_result ' Foobar {% invalid {% {% endraw ', '{% raw %} Foobar {% invalid {% {% endraw {% endraw %}'
-    assert_template_result ' Foobar {% {% {% ', '{% raw %} Foobar {% {% {% {% endraw %}'
-    assert_template_result ' test {% raw %} {% endraw %}', '{% raw %} test {% raw %} {% {% endraw %}endraw %}'
-    assert_template_result ' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}'
+    assert_template_result(' Foobar {% invalid ', '{% raw %} Foobar {% invalid {% endraw %}')
+    assert_template_result(' Foobar invalid %} ', '{% raw %} Foobar invalid %} {% endraw %}')
+    assert_template_result(' Foobar {{ invalid ', '{% raw %} Foobar {{ invalid {% endraw %}')
+    assert_template_result(' Foobar invalid }} ', '{% raw %} Foobar invalid }} {% endraw %}')
+    assert_template_result(' Foobar {% invalid {% {% endraw ', '{% raw %} Foobar {% invalid {% {% endraw {% endraw %}')
+    assert_template_result(' Foobar {% {% {% ', '{% raw %} Foobar {% {% {% {% endraw %}')
+    assert_template_result(' test {% raw %} {% endraw %}', '{% raw %} test {% raw %} {% {% endraw %}endraw %}')
+    assert_template_result(' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}')
   end
 
   def test_invalid_raw

test/integration/tags/render_tag_test.rb

@@ -7,39 +7,39 @@ class RenderTagTest < Minitest::Test
 
   def test_render_with_no_arguments
     Liquid::Template.file_system = StubFileSystem.new('source' => 'rendered content')
-    assert_template_result 'rendered content', '{% render "source" %}'
+    assert_template_result('rendered content', '{% render "source" %}')
   end
 
   def test_render_tag_looks_for_file_system_in_registers_first
     file_system = StubFileSystem.new('pick_a_source' => 'from register file system')
-    assert_equal 'from register file system',
-      Template.parse('{% render "pick_a_source" %}').render!({}, registers: { file_system: file_system })
+    assert_equal('from register file system',
+      Template.parse('{% render "pick_a_source" %}').render!({}, registers: { file_system: file_system }))
   end
 
   def test_render_passes_named_arguments_into_inner_scope
     Liquid::Template.file_system = StubFileSystem.new('product' => '{{ inner_product.title }}')
-    assert_template_result 'My Product', '{% render "product", inner_product: outer_product %}',
-      'outer_product' => { 'title' => 'My Product' }
+    assert_template_result('My Product', '{% render "product", inner_product: outer_product %}',
+      'outer_product' => { 'title' => 'My Product' })
   end
 
   def test_render_accepts_literals_as_arguments
     Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ price }}')
-    assert_template_result '123', '{% render "snippet", price: 123 %}'
+    assert_template_result('123', '{% render "snippet", price: 123 %}')
   end
 
   def test_render_accepts_multiple_named_arguments
     Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ one }} {{ two }}')
-    assert_template_result '1 2', '{% render "snippet", one: 1, two: 2 %}'
+    assert_template_result('1 2', '{% render "snippet", one: 1, two: 2 %}')
   end
 
   def test_render_does_not_inherit_parent_scope_variables
     Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ outer_variable }}')
-    assert_template_result '', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}'
+    assert_template_result('', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}')
   end
 
   def test_render_does_not_inherit_variable_with_same_name_as_snippet
     Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ snippet }}')
-    assert_template_result '', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}"
+    assert_template_result('', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}")
   end
 
   def test_render_sets_the_correct_template_name_for_errors
@@ -70,7 +70,7 @@ class RenderTagTest < Minitest::Test
 
   def test_render_does_not_mutate_parent_scope
     Liquid::Template.file_system = StubFileSystem.new('snippet' => '{% assign inner = 1 %}')
-    assert_template_result '', "{% render 'snippet' %}{{ inner }}"
+    assert_template_result('', "{% render 'snippet' %}{{ inner }}")
   end
 
   def test_nested_render_tag
@@ -78,7 +78,7 @@ class RenderTagTest < Minitest::Test
       'one' => "one {% render 'two' %}",
       'two' => 'two'
     )
-    assert_template_result 'one two', "{% render 'one' %}"
+    assert_template_result('one two', "{% render 'one' %}")
   end
 
   def test_recursively_rendered_template_does_not_produce_endless_loop
@@ -89,14 +89,12 @@ class RenderTagTest < Minitest::Test
     end
   end
 
-  def test_includes_and_renders_count_towards_the_same_recursion_limit
+  def test_sub_contexts_count_towards_the_same_recursion_limit
     Liquid::Template.file_system = StubFileSystem.new(
-      'loop_render' => '{% render "loop_include" %}',
-      'loop_include' => '{% include "loop_render" %}'
+      'loop_render' => '{% render "loop_render" %}',
     )
-
-    assert_raises Liquid::StackLevelError  do
-      Template.parse('{% render "loop_include" %}').render!
+    assert_raises Liquid::StackLevelError do
+      Template.parse('{% render "loop_render" %}').render!
     end
   end
 
@@ -110,42 +108,61 @@ 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 })
-    assert_equal 1, file_system.file_read_count
+      .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 1, file_system.file_read_count
+    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 2, file_system.file_read_count
+    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
     Liquid::Template.file_system = StubFileSystem.new('snippet' => 'my message')
-    assert_template_result 'my message', '{% if true %}{% render "snippet" %}{% endif %}'
+    assert_template_result('my message', '{% if true %}{% render "snippet" %}{% endif %}')
   end
 
   def test_break_through_render
     Liquid::Template.file_system = StubFileSystem.new('break' => '{% break %}')
-    assert_template_result '1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}'
-    assert_template_result '112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}'
+    assert_template_result('1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}')
+    assert_template_result('112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}')
   end
 
   def test_increment_is_isolated_between_renders
     Liquid::Template.file_system = StubFileSystem.new('incr' => '{% increment %}')
-    assert_template_result '010', '{% increment %}{% increment %}{% render "incr" %}'
+    assert_template_result('010', '{% increment %}{% increment %}{% render "incr" %}')
   end
 
   def test_decrement_is_isolated_between_renders
     Liquid::Template.file_system = StubFileSystem.new('decr' => '{% decrement %}')
-    assert_template_result '-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}'
+    assert_template_result('-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}')
+  end
+
+  def test_includes_will_not_render_inside_render_tag
+    Liquid::Template.file_system = StubFileSystem.new(
+      'foo' => 'bar',
+      'test_include' => '{% include "foo" %}'
+    )
+
+    assert_template_result('include usage is not allowed in this context', '{% render "test_include" %}')
+  end
+
+  def test_includes_will_not_render_inside_nested_sibling_tags
+    Liquid::Template.file_system = StubFileSystem.new(
+      'foo' => 'bar',
+      'nested_render_with_sibling_include' => '{% render "test_include" %}{% include "foo" %}',
+      'test_include' => '{% include "foo" %}'
+    )
+
+    assert_template_result('include usage is not allowed in this contextinclude usage is not allowed in this context', '{% render "nested_render_with_sibling_include" %}')
   end
 end

test/integration/tags/standard_tag_test.rb

@@ -176,11 +176,11 @@ class StandardTagTest < Minitest::Test
     # Example from the shopify forums
     code = "{% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }}"
     template = Liquid::Template.parse(code)
-    assert_equal "menswear",   template.render!("collection" => { 'handle' => 'menswear-jackets' })
-    assert_equal "menswear",   template.render!("collection" => { 'handle' => 'menswear-t-shirts' })
-    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'x' })
-    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'y' })
-    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'z' })
+    assert_equal("menswear",   template.render!("collection" => { 'handle' => 'menswear-jackets' }))
+    assert_equal("menswear",   template.render!("collection" => { 'handle' => 'menswear-t-shirts' }))
+    assert_equal("womenswear", template.render!("collection" => { 'handle' => 'x' }))
+    assert_equal("womenswear", template.render!("collection" => { 'handle' => 'y' }))
+    assert_equal("womenswear", template.render!("collection" => { 'handle' => 'z' }))
   end
 
   def test_case_when_or
@@ -214,7 +214,7 @@ class StandardTagTest < Minitest::Test
   end
 
   def test_assign
-    assert_template_result 'variable', '{% assign a = "variable"%}{{a}}'
+    assert_template_result('variable', '{% assign a = "variable"%}{{a}}')
   end
 
   def test_assign_unassigned
@@ -223,11 +223,11 @@ class StandardTagTest < Minitest::Test
   end
 
   def test_assign_an_empty_string
-    assert_template_result '', '{% assign a = ""%}{{a}}'
+    assert_template_result('', '{% assign a = ""%}{{a}}')
   end
 
   def test_assign_is_global
-    assert_template_result 'variable', '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}'
+    assert_template_result('variable', '{%for i in (1..2) %}{% assign a = "variable"%}{% endfor %}{{a}}')
   end
 
   def test_case_detects_bad_syntax
@@ -293,6 +293,6 @@ class StandardTagTest < Minitest::Test
   end
 
   def test_multiline_tag
-    assert_template_result '0 1 2 3', "0{%\nfor i in (1..3)\n%} {{\ni\n}}{%\nendfor\n%}"
+    assert_template_result('0 1 2 3', "0{%\nfor i in (1..3)\n%} {{\ni\n}}{%\nendfor\n%}")
   end
 end # StandardTagTest

test/integration/tags/statements_test.rb

@@ -7,75 +7,75 @@ class StatementsTest < Minitest::Test
 
   def test_true_eql_true
     text = ' {% if true == true %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
+    assert_template_result('  true  ', text)
   end
 
   def test_true_not_eql_true
     text = ' {% if true != true %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
+    assert_template_result('  false  ', text)
   end
 
   def test_true_lq_true
     text = ' {% if 0 > 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
+    assert_template_result('  false  ', text)
   end
 
   def test_one_lq_zero
     text = ' {% if 1 > 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
+    assert_template_result('  true  ', text)
   end
 
   def test_zero_lq_one
     text = ' {% if 0 < 1 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
+    assert_template_result('  true  ', text)
   end
 
   def test_zero_lq_or_equal_one
     text = ' {% if 0 <= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
+    assert_template_result('  true  ', text)
   end
 
   def test_zero_lq_or_equal_one_involving_nil
     text = ' {% if null <= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
+    assert_template_result('  false  ', text)
 
     text = ' {% if 0 <= null %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text
+    assert_template_result('  false  ', text)
   end
 
   def test_zero_lqq_or_equal_one
     text = ' {% if 0 >= 0 %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text
+    assert_template_result('  true  ', text)
   end
 
   def test_strings
     text = " {% if 'test' == 'test' %} true {% else %} false {% endif %} "
-    assert_template_result '  true  ', text
+    assert_template_result('  true  ', text)
   end
 
   def test_strings_not_equal
     text = " {% if 'test' != 'test' %} true {% else %} false {% endif %} "
-    assert_template_result '  false  ', text
+    assert_template_result('  false  ', text)
   end
 
   def test_var_strings_equal
     text = ' {% if var == "hello there!" %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
+    assert_template_result('  true  ', text, 'var' => 'hello there!')
   end
 
   def test_var_strings_are_not_equal
     text = ' {% if "hello there!" == var %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
+    assert_template_result('  true  ', text, 'var' => 'hello there!')
   end
 
   def test_var_and_long_string_are_equal
     text = " {% if var == 'hello there!' %} true {% else %} false {% endif %} "
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
+    assert_template_result('  true  ', text, 'var' => 'hello there!')
   end
 
   def test_var_and_long_string_are_equal_backwards
     text = " {% if 'hello there!' == var %} true {% else %} false {% endif %} "
-    assert_template_result '  true  ', text, 'var' => 'hello there!'
+    assert_template_result('  true  ', text, 'var' => 'hello there!')
   end
 
   # def test_is_nil
@@ -87,27 +87,27 @@ class StatementsTest < Minitest::Test
 
   def test_is_collection_empty
     text = ' {% if array == empty %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'array' => []
+    assert_template_result('  true  ', text, 'array' => [])
   end
 
   def test_is_not_collection_empty
     text = ' {% if array == empty %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text, 'array' => [1, 2, 3]
+    assert_template_result('  false  ', text, 'array' => [1, 2, 3])
   end
 
   def test_nil
     text = ' {% if var == nil %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => nil
+    assert_template_result('  true  ', text, 'var' => nil)
 
     text = ' {% if var == null %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => nil
+    assert_template_result('  true  ', text, 'var' => nil)
   end
 
   def test_not_nil
     text = ' {% if var != nil %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 1
+    assert_template_result('  true  ', text, 'var' => 1)
 
     text = ' {% if var != null %} true {% else %} false {% endif %} '
-    assert_template_result '  true  ', text, 'var' => 1
+    assert_template_result('  true  ', text, 'var' => 1)
   end
 end # StatementsTest

test/integration/tags/unless_else_tag_test.rb

@@ -19,10 +19,10 @@ class UnlessElseTagTest < Minitest::Test
   end
 
   def test_unless_in_loop
-    assert_template_result '23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false]
+    assert_template_result('23', '{% for i in choices %}{% unless i %}{{ forloop.index }}{% endunless %}{% endfor %}', 'choices' => [1, nil, false])
   end
 
   def test_unless_else_in_loop
-    assert_template_result ' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false]
+    assert_template_result(' TRUE  2  3 ', '{% for i in choices %}{% unless i %} {{ forloop.index }} {% else %} TRUE {% endunless %}{% endfor %}', 'choices' => [1, nil, false])
   end
 end # UnlessElseTest

test/integration/template_test.rb

@@ -40,8 +40,8 @@ class TemplateTest < Minitest::Test
 
   def test_instance_assigns_persist_on_same_template_object_between_parses
     t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
+    assert_equal('from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!)
+    assert_equal('from instance assigns', t.parse("{{ foo }}").render!)
   end
 
   def test_warnings_is_not_exponential_time
@@ -51,32 +51,32 @@ class TemplateTest < Minitest::Test
     end
 
     t = Template.parse(str)
-    assert_equal [], Timeout.timeout(1) { t.warnings }
+    assert_equal([], Timeout.timeout(1) { t.warnings })
   end
 
   def test_instance_assigns_persist_on_same_template_parsing_between_renders
     t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
-    assert_equal 'foo', t.render!
-    assert_equal 'foofoo', t.render!
+    assert_equal('foo', t.render!)
+    assert_equal('foofoo', t.render!)
   end
 
   def test_custom_assigns_do_not_persist_on_same_template
     t = Template.new
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
-    assert_equal '', t.parse("{{ foo }}").render!
+    assert_equal('from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns'))
+    assert_equal('', t.parse("{{ foo }}").render!)
   end
 
   def test_custom_assigns_squash_instance_assigns
     t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
+    assert_equal('from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!)
+    assert_equal('from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns'))
   end
 
   def test_persistent_assigns_squash_instance_assigns
     t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
+    assert_equal('from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!)
     t.assigns['foo'] = 'from persistent assigns'
-    assert_equal 'from persistent assigns', t.parse("{{ foo }}").render!
+    assert_equal('from persistent assigns', t.parse("{{ foo }}").render!)
   end
 
   def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
@@ -85,9 +85,9 @@ class TemplateTest < Minitest::Test
       @global ||= 0
       @global += 1
     }
-    assert_equal '1', t.parse("{{number}}").render!
-    assert_equal '1', t.parse("{{number}}").render!
-    assert_equal '1', t.render!
+    assert_equal('1', t.parse("{{number}}").render!)
+    assert_equal('1', t.parse("{{number}}").render!)
+    assert_equal('1', t.render!)
     @global = nil
   end
 
@@ -97,138 +97,138 @@ class TemplateTest < Minitest::Test
                               @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)
+    assert_equal('1', t.parse("{{number}}").render!(assigns))
+    assert_equal('1', t.parse("{{number}}").render!(assigns))
+    assert_equal('1', t.render!(assigns))
     @global = nil
   end
 
   def test_resource_limits_works_with_custom_length_method
     t = Template.parse("{% assign foo = bar %}")
     t.resource_limits.render_length_limit = 42
-    assert_equal "", t.render!("bar" => SomethingWithLength.new)
+    assert_equal("", t.render!("bar" => SomethingWithLength.new))
   end
 
   def test_resource_limits_render_length
     t = Template.parse("0123456789")
     t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.render_length_limit = 10
-    assert_equal "0123456789", t.render!
-    refute_nil t.resource_limits.render_length
+    assert_equal("0123456789", t.render!)
+    refute_nil(t.resource_limits.render_length)
   end
 
   def test_resource_limits_render_score
     t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.render_score_limit = 200
-    assert_equal (" foo " * 100), t.render!
-    refute_nil t.resource_limits.render_score
+    assert_equal((" foo " * 100), t.render!)
+    refute_nil(t.resource_limits.render_score)
   end
 
   def test_resource_limits_assign_score
     t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
     t.resource_limits.assign_score_limit = 1
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.assign_score_limit = 2
-    assert_equal "", t.render!
-    refute_nil t.resource_limits.assign_score
+    assert_equal("", t.render!)
+    refute_nil(t.resource_limits.assign_score)
   end
 
   def test_resource_limits_assign_score_counts_bytes_not_characters
     t = Template.parse("{% assign foo = 'すごい' %}")
     t.render
-    assert_equal 9, t.resource_limits.assign_score
+    assert_equal(9, t.resource_limits.assign_score)
 
     t = Template.parse("{% capture foo %}すごい{% endcapture %}")
     t.render
-    assert_equal 9, t.resource_limits.assign_score
+    assert_equal(9, t.resource_limits.assign_score)
   end
 
   def test_resource_limits_assign_score_nested
     t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
 
     t.resource_limits.assign_score_limit = 3
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.assign_score_limit = 5
-    assert_equal "", t.render!
+    assert_equal("", t.render!)
   end
 
   def test_resource_limits_aborts_rendering_after_first_error
     t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render
-    assert t.resource_limits.reached?
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
   end
 
   def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
     t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
     t.render!
-    assert t.resource_limits.assign_score > 0
-    assert t.resource_limits.render_score > 0
-    assert t.resource_limits.render_length > 0
+    assert(t.resource_limits.assign_score > 0)
+    assert(t.resource_limits.render_score > 0)
+    assert(t.resource_limits.render_length > 0)
   end
 
   def test_render_length_persists_between_blocks
     t = Template.parse("{% if true %}aaaa{% endif %}")
     t.resource_limits.render_length_limit = 7
-    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
     t.resource_limits.render_length_limit = 8
-    assert_equal "aaaa", t.render
+    assert_equal("aaaa", t.render)
 
     t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
     t.resource_limits.render_length_limit = 13
-    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
     t.resource_limits.render_length_limit = 14
-    assert_equal "aaaabbb", t.render
+    assert_equal("aaaabbb", t.render)
 
     t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
     t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
     t.resource_limits.render_length_limit = 11
-    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
     t.resource_limits.render_length_limit = 12
-    assert_equal "ababab", t.render
+    assert_equal("ababab", t.render)
   end
 
   def test_render_length_uses_number_of_bytes_not_characters
     t = Template.parse("{% if true %}すごい{% endif %}")
     t.resource_limits.render_length_limit = 10
-    assert_equal "Liquid error: Memory limits exceeded", t.render
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
     t.resource_limits.render_length_limit = 18
-    assert_equal "すごい", t.render
+    assert_equal("すごい", t.render)
   end
 
   def test_default_resource_limits_unaffected_by_render_with_context
     context = Context.new
     t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
     t.render!(context)
-    assert context.resource_limits.assign_score > 0
-    assert context.resource_limits.render_score > 0
-    assert context.resource_limits.render_length > 0
+    assert(context.resource_limits.assign_score > 0)
+    assert(context.resource_limits.render_score > 0)
+    assert(context.resource_limits.render_length > 0)
   end
 
   def test_can_use_drop_as_context
     t = Template.new
     t.registers['lulz'] = 'haha'
     drop = TemplateContextDrop.new
-    assert_equal 'fizzbuzz', t.parse('{{foo}}').render!(drop)
-    assert_equal 'bar', t.parse('{{bar}}').render!(drop)
-    assert_equal 'haha', t.parse("{{baz}}").render!(drop)
+    assert_equal('fizzbuzz', t.parse('{{foo}}').render!(drop))
+    assert_equal('bar', t.parse('{{bar}}').render!(drop))
+    assert_equal('haha', t.parse("{{baz}}").render!(drop))
   end
 
   def test_render_bang_force_rethrow_errors_on_passed_context
@@ -238,7 +238,7 @@ class TemplateTest < Minitest::Test
     e = assert_raises RuntimeError do
       t.render!(context)
     end
-    assert_equal 'ruby error in drop', e.message
+    assert_equal('ruby error in drop', e.message)
   end
 
   def test_exception_renderer_that_returns_string
@@ -250,8 +250,8 @@ class TemplateTest < Minitest::Test
 
     output = Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_renderer: handler)
 
-    assert exception.is_a?(Liquid::ZeroDivisionError)
-    assert_equal '<!-- error -->', output
+    assert(exception.is_a?(Liquid::ZeroDivisionError))
+    assert_equal('<!-- error -->', output)
   end
 
   def test_exception_renderer_that_raises
@@ -262,35 +262,35 @@ class TemplateTest < Minitest::Test
                                                                                  raise
                                                                                })
     end
-    assert exception.is_a?(Liquid::ZeroDivisionError)
+    assert(exception.is_a?(Liquid::ZeroDivisionError))
   end
 
   def test_global_filter_option_on_render
     global_filter_proc = ->(output) { "#{output} filtered" }
     rendered_template = Template.parse("{{name}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
 
-    assert_equal 'bob filtered', rendered_template
+    assert_equal('bob filtered', rendered_template)
   end
 
   def test_global_filter_option_when_native_filters_exist
     global_filter_proc = ->(output) { "#{output} filtered" }
     rendered_template = Template.parse("{{name | upcase}}").render({ "name" => "bob" }, global_filter: global_filter_proc)
 
-    assert_equal 'BOB filtered', rendered_template
+    assert_equal('BOB filtered', rendered_template)
   end
 
   def test_undefined_variables
     t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
     result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true)
 
-    assert_equal '33  32  ', result
-    assert_equal 3, t.errors.count
-    assert_instance_of Liquid::UndefinedVariable, t.errors[0]
-    assert_equal 'Liquid error: undefined variable y', t.errors[0].message
-    assert_instance_of Liquid::UndefinedVariable, t.errors[1]
-    assert_equal 'Liquid error: undefined variable b', t.errors[1].message
-    assert_instance_of Liquid::UndefinedVariable, t.errors[2]
-    assert_equal 'Liquid error: undefined variable d', t.errors[2].message
+    assert_equal('33  32  ', result)
+    assert_equal(3, t.errors.count)
+    assert_instance_of(Liquid::UndefinedVariable, t.errors[0])
+    assert_equal('Liquid error: undefined variable y', t.errors[0].message)
+    assert_instance_of(Liquid::UndefinedVariable, t.errors[1])
+    assert_equal('Liquid error: undefined variable b', t.errors[1].message)
+    assert_instance_of(Liquid::UndefinedVariable, t.errors[2])
+    assert_equal('Liquid error: undefined variable d', t.errors[2].message)
   end
 
   def test_nil_value_does_not_raise
@@ -298,8 +298,8 @@ class TemplateTest < Minitest::Test
     t = Template.parse("some{{x}}thing")
     result = t.render!({ 'x' => nil }, strict_variables: true)
 
-    assert_equal 0, t.errors.count
-    assert_equal 'something', result
+    assert_equal(0, t.errors.count)
+    assert_equal('something', result)
   end
 
   def test_undefined_variables_raise
@@ -315,9 +315,9 @@ class TemplateTest < Minitest::Test
     t = Template.new.parse('{{ foo }} {{ woot }}')
     result = t.render(d, strict_variables: true)
 
-    assert_equal 'foo ', result
-    assert_equal 1, t.errors.count
-    assert_instance_of Liquid::UndefinedDropMethod, t.errors[0]
+    assert_equal('foo ', result)
+    assert_equal(1, t.errors.count)
+    assert_instance_of(Liquid::UndefinedDropMethod, t.errors[0])
   end
 
   def test_undefined_drop_methods_raise
@@ -338,10 +338,10 @@ class TemplateTest < Minitest::Test
     end
     result = t.render({ 'a' => 123, 'x' => 'foo' }, filters: [filters], strict_filters: true)
 
-    assert_equal '123 ', result
-    assert_equal 1, t.errors.count
-    assert_instance_of Liquid::UndefinedFilter, t.errors[0]
-    assert_equal 'Liquid error: undefined filter somefilter1', t.errors[0].message
+    assert_equal('123 ', result)
+    assert_equal(1, t.errors.count)
+    assert_instance_of(Liquid::UndefinedFilter, t.errors[0])
+    assert_equal('Liquid error: undefined filter somefilter1', t.errors[0].message)
   end
 
   def test_undefined_filters_raise
@@ -355,10 +355,10 @@ class TemplateTest < Minitest::Test
   def test_using_range_literal_works_as_expected
     t = Template.parse("{% assign foo = (x..y) %}{{ foo }}")
     result = t.render('x' => 1, 'y' => 5)
-    assert_equal '1..5', result
+    assert_equal('1..5', result)
 
     t = Template.parse("{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}")
     result = t.render('x' => 1, 'y' => 5)
-    assert_equal '12345', result
+    assert_equal('12345', result)
   end
 end

test/integration/variable_test.rb

@@ -7,92 +7,92 @@ class VariableTest < Minitest::Test
 
   def test_simple_variable
     template = Template.parse(%({{test}}))
-    assert_equal 'worked', template.render!('test' => 'worked')
-    assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
+    assert_equal('worked', template.render!('test' => 'worked'))
+    assert_equal('worked wonderfully', template.render!('test' => 'worked wonderfully'))
   end
 
   def test_variable_render_calls_to_liquid
-    assert_template_result 'foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new
+    assert_template_result('foobar', '{{ foo }}', 'foo' => ThingWithToLiquid.new)
   end
 
   def test_simple_with_whitespaces
     template = Template.parse(%(  {{ test }}  ))
-    assert_equal '  worked  ', template.render!('test' => 'worked')
-    assert_equal '  worked wonderfully  ', template.render!('test' => 'worked wonderfully')
+    assert_equal('  worked  ', template.render!('test' => 'worked'))
+    assert_equal('  worked wonderfully  ', template.render!('test' => 'worked wonderfully'))
   end
 
   def test_ignore_unknown
     template = Template.parse(%({{ test }}))
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_using_blank_as_variable_name
     template = Template.parse("{% assign foo = blank %}{{ foo }}")
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_using_empty_as_variable_name
     template = Template.parse("{% assign foo = empty %}{{ foo }}")
-    assert_equal '', template.render!
+    assert_equal('', template.render!)
   end
 
   def test_hash_scoping
     template = Template.parse(%({{ test.test }}))
-    assert_equal 'worked', template.render!('test' => { 'test' => 'worked' })
+    assert_equal('worked', template.render!('test' => { 'test' => 'worked' }))
   end
 
   def test_false_renders_as_false
-    assert_equal 'false', Template.parse("{{ foo }}").render!('foo' => false)
-    assert_equal 'false', Template.parse("{{ false }}").render!
+    assert_equal('false', Template.parse("{{ foo }}").render!('foo' => false))
+    assert_equal('false', Template.parse("{{ false }}").render!)
   end
 
   def test_nil_renders_as_empty_string
-    assert_equal '', Template.parse("{{ nil }}").render!
-    assert_equal 'cat', Template.parse("{{ nil | append: 'cat' }}").render!
+    assert_equal('', Template.parse("{{ nil }}").render!)
+    assert_equal('cat', Template.parse("{{ nil | append: 'cat' }}").render!)
   end
 
   def test_preset_assigns
     template = Template.parse(%({{ test }}))
     template.assigns['test'] = 'worked'
-    assert_equal 'worked', template.render!
+    assert_equal('worked', template.render!)
   end
 
   def test_reuse_parsed_template
     template = Template.parse(%({{ greeting }} {{ name }}))
     template.assigns['greeting'] = 'Goodbye'
-    assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
-    assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
-    assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
-    assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
+    assert_equal('Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi'))
+    assert_equal('Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi'))
+    assert_equal('Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian'))
+    assert_equal('Goodbye Brian', template.render!('name' => 'Brian'))
     assert_equal({ 'greeting' => 'Goodbye' }, template.assigns)
   end
 
   def test_assigns_not_polluted_from_template
     template = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
     template.assigns['test'] = 'baz'
-    assert_equal 'bazbar', template.render!
-    assert_equal 'bazbar', template.render!
-    assert_equal 'foobar', template.render!('test' => 'foo')
-    assert_equal 'bazbar', template.render!
+    assert_equal('bazbar', template.render!)
+    assert_equal('bazbar', template.render!)
+    assert_equal('foobar', template.render!('test' => 'foo'))
+    assert_equal('bazbar', template.render!)
   end
 
   def test_hash_with_default_proc
     template = Template.parse(%(Hello {{ test }}))
     assigns = Hash.new { |_h, k| raise "Unknown variable '#{k}'" }
     assigns['test'] = 'Tobi'
-    assert_equal 'Hello Tobi', template.render!(assigns)
+    assert_equal('Hello Tobi', template.render!(assigns))
     assigns.delete('test')
     e = assert_raises(RuntimeError) do
       template.render!(assigns)
     end
-    assert_equal "Unknown variable 'test'", e.message
+    assert_equal("Unknown variable 'test'", e.message)
   end
 
   def test_multiline_variable
-    assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
+    assert_equal('worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked'))
   end
 
   def test_render_symbol
-    assert_template_result 'bar', '{{ foo }}', 'foo' => :bar
+    assert_template_result('bar', '{{ foo }}', 'foo' => :bar)
   end
 end

test/test_helper.rb

@@ -38,20 +38,20 @@ module Minitest
     include Liquid
 
     def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template, line_numbers: true).render!(assigns), message
+      assert_equal(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
     end
 
     def assert_template_result_matches(expected, template, assigns = {}, message = nil)
       return assert_template_result(expected, template, assigns, message) unless expected.is_a?(Regexp)
 
-      assert_match expected, Template.parse(template, line_numbers: true).render!(assigns), message
+      assert_match(expected, Template.parse(template, line_numbers: true).render!(assigns), message)
     end
 
     def assert_match_syntax_error(match, template, assigns = {})
       exception = assert_raises(Liquid::SyntaxError) do
         Template.parse(template, line_numbers: true).render(assigns)
       end
-      assert_match match, exception.message
+      assert_match(match, exception.message)
     end
 
     def with_global_filter(*globals)

test/unit/block_unit_test.rb

@@ -7,42 +7,42 @@ class BlockUnitTest < Minitest::Test
 
   def test_blankspace
     template = Liquid::Template.parse("  ")
-    assert_equal ["  "], template.root.nodelist
+    assert_equal(["  "], template.root.nodelist)
   end
 
   def test_variable_beginning
     template = Liquid::Template.parse("{{funk}}  ")
-    assert_equal 2, template.root.nodelist.size
-    assert_equal Variable, template.root.nodelist[0].class
-    assert_equal String, template.root.nodelist[1].class
+    assert_equal(2, template.root.nodelist.size)
+    assert_equal(Variable, template.root.nodelist[0].class)
+    assert_equal(String, template.root.nodelist[1].class)
   end
 
   def test_variable_end
     template = Liquid::Template.parse("  {{funk}}")
-    assert_equal 2, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
-    assert_equal Variable, template.root.nodelist[1].class
+    assert_equal(2, template.root.nodelist.size)
+    assert_equal(String, template.root.nodelist[0].class)
+    assert_equal(Variable, template.root.nodelist[1].class)
   end
 
   def test_variable_middle
     template = Liquid::Template.parse("  {{funk}}  ")
-    assert_equal 3, template.root.nodelist.size
-    assert_equal String, template.root.nodelist[0].class
-    assert_equal Variable, template.root.nodelist[1].class
-    assert_equal String, template.root.nodelist[2].class
+    assert_equal(3, template.root.nodelist.size)
+    assert_equal(String, template.root.nodelist[0].class)
+    assert_equal(Variable, template.root.nodelist[1].class)
+    assert_equal(String, template.root.nodelist[2].class)
   end
 
   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(7, template.root.nodelist.size)
+    assert_equal([String, Variable, String, Variable, String, Variable, String],
+      block_types(template.root.nodelist))
   end
 
   def test_with_block
     template = Liquid::Template.parse("  {% comment %} {% endcomment %} ")
-    assert_equal [String, Comment, String], block_types(template.root.nodelist)
-    assert_equal 3, template.root.nodelist.size
+    assert_equal([String, Comment, String], block_types(template.root.nodelist))
+    assert_equal(3, template.root.nodelist.size)
   end
 
   def test_with_custom_tag

test/unit/condition_unit_test.rb

@@ -10,68 +10,68 @@ class ConditionUnitTest < Minitest::Test
   end
 
   def test_basic_condition
-    assert_equal false, Condition.new(1, '==', 2).evaluate
-    assert_equal true,  Condition.new(1, '==', 1).evaluate
+    assert_equal(false, Condition.new(1, '==', 2).evaluate)
+    assert_equal(true,  Condition.new(1, '==', 1).evaluate)
   end
 
   def test_default_operators_evalute_true
-    assert_evaluates_true 1, '==', 1
-    assert_evaluates_true 1, '!=', 2
-    assert_evaluates_true 1, '<>', 2
-    assert_evaluates_true 1, '<', 2
-    assert_evaluates_true 2, '>', 1
-    assert_evaluates_true 1, '>=', 1
-    assert_evaluates_true 2, '>=', 1
-    assert_evaluates_true 1, '<=', 2
-    assert_evaluates_true 1, '<=', 1
+    assert_evaluates_true(1, '==', 1)
+    assert_evaluates_true(1, '!=', 2)
+    assert_evaluates_true(1, '<>', 2)
+    assert_evaluates_true(1, '<', 2)
+    assert_evaluates_true(2, '>', 1)
+    assert_evaluates_true(1, '>=', 1)
+    assert_evaluates_true(2, '>=', 1)
+    assert_evaluates_true(1, '<=', 2)
+    assert_evaluates_true(1, '<=', 1)
     # negative numbers
-    assert_evaluates_true 1, '>', -1
+    assert_evaluates_true(1, '>', -1)
     assert_evaluates_true(-1, '<', 1)
-    assert_evaluates_true 1.0, '>', -1.0
+    assert_evaluates_true(1.0, '>', -1.0)
     assert_evaluates_true(-1.0, '<', 1.0)
   end
 
   def test_default_operators_evalute_false
-    assert_evaluates_false 1, '==', 2
-    assert_evaluates_false 1, '!=', 1
-    assert_evaluates_false 1, '<>', 1
-    assert_evaluates_false 1, '<', 0
-    assert_evaluates_false 2, '>', 4
-    assert_evaluates_false 1, '>=', 3
-    assert_evaluates_false 2, '>=', 4
-    assert_evaluates_false 1, '<=', 0
-    assert_evaluates_false 1, '<=', 0
+    assert_evaluates_false(1, '==', 2)
+    assert_evaluates_false(1, '!=', 1)
+    assert_evaluates_false(1, '<>', 1)
+    assert_evaluates_false(1, '<', 0)
+    assert_evaluates_false(2, '>', 4)
+    assert_evaluates_false(1, '>=', 3)
+    assert_evaluates_false(2, '>=', 4)
+    assert_evaluates_false(1, '<=', 0)
+    assert_evaluates_false(1, '<=', 0)
   end
 
   def test_contains_works_on_strings
-    assert_evaluates_true 'bob', 'contains', 'o'
-    assert_evaluates_true 'bob', 'contains', 'b'
-    assert_evaluates_true 'bob', 'contains', 'bo'
-    assert_evaluates_true 'bob', 'contains', 'ob'
-    assert_evaluates_true 'bob', 'contains', 'bob'
+    assert_evaluates_true('bob', 'contains', 'o')
+    assert_evaluates_true('bob', 'contains', 'b')
+    assert_evaluates_true('bob', 'contains', 'bo')
+    assert_evaluates_true('bob', 'contains', 'ob')
+    assert_evaluates_true('bob', 'contains', 'bob')
 
-    assert_evaluates_false 'bob', 'contains', 'bob2'
-    assert_evaluates_false 'bob', 'contains', 'a'
-    assert_evaluates_false 'bob', 'contains', '---'
+    assert_evaluates_false('bob', 'contains', 'bob2')
+    assert_evaluates_false('bob', 'contains', 'a')
+    assert_evaluates_false('bob', 'contains', '---')
   end
 
   def test_invalid_comparation_operator
-    assert_evaluates_argument_error 1, '~~', 0
+    assert_evaluates_argument_error(1, '~~', 0)
   end
 
   def test_comparation_of_int_and_str
-    assert_evaluates_argument_error '1', '>', 0
-    assert_evaluates_argument_error '1', '<', 0
-    assert_evaluates_argument_error '1', '>=', 0
-    assert_evaluates_argument_error '1', '<=', 0
+    assert_evaluates_argument_error('1', '>', 0)
+    assert_evaluates_argument_error('1', '<', 0)
+    assert_evaluates_argument_error('1', '>=', 0)
+    assert_evaluates_argument_error('1', '<=', 0)
   end
 
   def test_hash_compare_backwards_compatibility
-    assert_nil Condition.new({}, '>', 2).evaluate
-    assert_nil Condition.new(2, '>', {}).evaluate
-    assert_equal false, Condition.new({}, '==', 2).evaluate
-    assert_equal true, Condition.new({ 'a' => 1 }, '==', 'a' => 1).evaluate
-    assert_equal true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate
+    assert_nil(Condition.new({}, '>', 2).evaluate)
+    assert_nil(Condition.new(2, '>', {}).evaluate)
+    assert_equal(false, Condition.new({}, '==', 2).evaluate)
+    assert_equal(true, Condition.new({ 'a' => 1 }, '==', 'a' => 1).evaluate)
+    assert_equal(true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate)
   end
 
   def test_contains_works_on_arrays
@@ -79,64 +79,64 @@ class ConditionUnitTest < Minitest::Test
     @context['array'] = [1, 2, 3, 4, 5]
     array_expr = VariableLookup.new("array")
 
-    assert_evaluates_false array_expr, 'contains', 0
-    assert_evaluates_true array_expr, 'contains', 1
-    assert_evaluates_true array_expr, 'contains', 2
-    assert_evaluates_true array_expr, 'contains', 3
-    assert_evaluates_true array_expr, 'contains', 4
-    assert_evaluates_true array_expr, 'contains', 5
-    assert_evaluates_false array_expr, 'contains', 6
-    assert_evaluates_false array_expr, 'contains', "1"
+    assert_evaluates_false(array_expr, 'contains', 0)
+    assert_evaluates_true(array_expr, 'contains', 1)
+    assert_evaluates_true(array_expr, 'contains', 2)
+    assert_evaluates_true(array_expr, 'contains', 3)
+    assert_evaluates_true(array_expr, 'contains', 4)
+    assert_evaluates_true(array_expr, 'contains', 5)
+    assert_evaluates_false(array_expr, 'contains', 6)
+    assert_evaluates_false(array_expr, 'contains', "1")
   end
 
   def test_contains_returns_false_for_nil_operands
     @context = Liquid::Context.new
-    assert_evaluates_false VariableLookup.new('not_assigned'), 'contains', '0'
-    assert_evaluates_false 0, 'contains', VariableLookup.new('not_assigned')
+    assert_evaluates_false(VariableLookup.new('not_assigned'), 'contains', '0')
+    assert_evaluates_false(0, 'contains', VariableLookup.new('not_assigned'))
   end
 
   def test_contains_return_false_on_wrong_data_type
-    assert_evaluates_false 1, 'contains', 0
+    assert_evaluates_false(1, 'contains', 0)
   end
 
   def test_contains_with_string_left_operand_coerces_right_operand_to_string
-    assert_evaluates_true ' 1 ', 'contains', 1
-    assert_evaluates_false ' 1 ', 'contains', 2
+    assert_evaluates_true(' 1 ', 'contains', 1)
+    assert_evaluates_false(' 1 ', 'contains', 2)
   end
 
   def test_or_condition
     condition = Condition.new(1, '==', 2)
 
-    assert_equal false, condition.evaluate
+    assert_equal(false, condition.evaluate)
 
     condition.or(Condition.new(2, '==', 1))
 
-    assert_equal false, condition.evaluate
+    assert_equal(false, condition.evaluate)
 
     condition.or(Condition.new(1, '==', 1))
 
-    assert_equal true, condition.evaluate
+    assert_equal(true, condition.evaluate)
   end
 
   def test_and_condition
     condition = Condition.new(1, '==', 1)
 
-    assert_equal true, condition.evaluate
+    assert_equal(true, condition.evaluate)
 
     condition.and(Condition.new(2, '==', 2))
 
-    assert_equal true, condition.evaluate
+    assert_equal(true, condition.evaluate)
 
     condition.and(Condition.new(2, '==', 1))
 
-    assert_equal false, condition.evaluate
+    assert_equal(false, condition.evaluate)
   end
 
   def test_should_allow_custom_proc_operator
     Condition.operators['starts_with'] = proc { |_cond, left, right| left =~ /^#{right}/ }
 
-    assert_evaluates_true 'bob', 'starts_with', 'b'
-    assert_evaluates_false 'bob', 'starts_with', 'o'
+    assert_evaluates_true('bob', 'starts_with', 'b')
+    assert_evaluates_false('bob', 'starts_with', 'o')
   ensure
     Condition.operators.delete('starts_with')
   end
@@ -145,19 +145,19 @@ class ConditionUnitTest < Minitest::Test
     @context = Liquid::Context.new
     @context['one'] = @context['another'] = "gnomeslab-and-or-liquid"
 
-    assert_evaluates_true VariableLookup.new("one"), '==', VariableLookup.new("another")
+    assert_evaluates_true(VariableLookup.new("one"), '==', VariableLookup.new("another"))
   end
 
   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/context_unit_test.rb

@@ -74,34 +74,34 @@ class ContextUnitTest < Minitest::Test
 
   def test_variables
     @context['string'] = 'string'
-    assert_equal 'string', @context['string']
+    assert_equal('string', @context['string'])
 
     @context['num'] = 5
-    assert_equal 5, @context['num']
+    assert_equal(5, @context['num'])
 
     @context['time'] = Time.parse('2006-06-06 12:00:00')
-    assert_equal Time.parse('2006-06-06 12:00:00'), @context['time']
+    assert_equal(Time.parse('2006-06-06 12:00:00'), @context['time'])
 
     @context['date'] = Date.today
-    assert_equal Date.today, @context['date']
+    assert_equal(Date.today, @context['date'])
 
     now = Time.now
     @context['datetime'] = now
-    assert_equal now, @context['datetime']
+    assert_equal(now, @context['datetime'])
 
     @context['bool'] = true
-    assert_equal true, @context['bool']
+    assert_equal(true, @context['bool'])
 
     @context['bool'] = false
-    assert_equal false, @context['bool']
+    assert_equal(false, @context['bool'])
 
     @context['nil'] = nil
-    assert_nil @context['nil']
-    assert_nil @context['nil']
+    assert_nil(@context['nil'])
+    assert_nil(@context['nil'])
   end
 
   def test_variables_not_existing
-    assert_nil @context['does_not_exist']
+    assert_nil(@context['does_not_exist'])
   end
 
   def test_scoping
@@ -122,20 +122,20 @@ class ContextUnitTest < Minitest::Test
   def test_length_query
     @context['numbers'] = [1, 2, 3, 4]
 
-    assert_equal 4, @context['numbers.size']
+    assert_equal(4, @context['numbers.size'])
 
     @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
 
-    assert_equal 4, @context['numbers.size']
+    assert_equal(4, @context['numbers.size'])
 
     @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
 
-    assert_equal 1000, @context['numbers.size']
+    assert_equal(1000, @context['numbers.size'])
   end
 
   def test_hyphenated_variable
     @context['oh-my'] = 'godz'
-    assert_equal 'godz', @context['oh-my']
+    assert_equal('godz', @context['oh-my'])
   end
 
   def test_add_filter
@@ -147,13 +147,13 @@ class ContextUnitTest < Minitest::Test
 
     context = Context.new
     context.add_filters(filter)
-    assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
+    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
 
     context = Context.new
-    assert_equal 'hi?', context.invoke(:hi, 'hi?')
+    assert_equal('hi?', context.invoke(:hi, 'hi?'))
 
     context.add_filters(filter)
-    assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
+    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
   end
 
   def test_only_intended_filters_make_it_there
@@ -164,75 +164,75 @@ class ContextUnitTest < Minitest::Test
     end
 
     context = Context.new
-    assert_equal "Wookie", context.invoke("hi", "Wookie")
+    assert_equal("Wookie", context.invoke("hi", "Wookie"))
 
     context.add_filters(filter)
-    assert_equal "Wookie hi!", context.invoke("hi", "Wookie")
+    assert_equal("Wookie hi!", context.invoke("hi", "Wookie"))
   end
 
   def test_add_item_in_outer_scope
     @context['test'] = 'test'
     @context.push
-    assert_equal 'test', @context['test']
+    assert_equal('test', @context['test'])
     @context.pop
-    assert_equal 'test', @context['test']
+    assert_equal('test', @context['test'])
   end
 
   def test_add_item_in_inner_scope
     @context.push
     @context['test'] = 'test'
-    assert_equal 'test', @context['test']
+    assert_equal('test', @context['test'])
     @context.pop
-    assert_nil @context['test']
+    assert_nil(@context['test'])
   end
 
   def test_hierachical_data
     @context['hash'] = { "name" => 'tobi' }
-    assert_equal 'tobi', @context['hash.name']
-    assert_equal 'tobi', @context['hash["name"]']
+    assert_equal('tobi', @context['hash.name'])
+    assert_equal('tobi', @context['hash["name"]'])
   end
 
   def test_keywords
-    assert_equal true, @context['true']
-    assert_equal false, @context['false']
+    assert_equal(true, @context['true'])
+    assert_equal(false, @context['false'])
   end
 
   def test_digits
-    assert_equal 100, @context['100']
-    assert_equal 100.00, @context['100.00']
+    assert_equal(100, @context['100'])
+    assert_equal(100.00, @context['100.00'])
   end
 
   def test_strings
-    assert_equal "hello!", @context['"hello!"']
-    assert_equal "hello!", @context["'hello!'"]
+    assert_equal("hello!", @context['"hello!"'])
+    assert_equal("hello!", @context["'hello!'"])
   end
 
   def test_merge
     @context.merge("test" => "test")
-    assert_equal 'test', @context['test']
+    assert_equal('test', @context['test'])
     @context.merge("test" => "newvalue", "foo" => "bar")
-    assert_equal 'newvalue', @context['test']
-    assert_equal 'bar', @context['foo']
+    assert_equal('newvalue', @context['test'])
+    assert_equal('bar', @context['foo'])
   end
 
   def test_array_notation
     @context['test'] = [1, 2, 3, 4, 5]
 
-    assert_equal 1, @context['test[0]']
-    assert_equal 2, @context['test[1]']
-    assert_equal 3, @context['test[2]']
-    assert_equal 4, @context['test[3]']
-    assert_equal 5, @context['test[4]']
+    assert_equal(1, @context['test[0]'])
+    assert_equal(2, @context['test[1]'])
+    assert_equal(3, @context['test[2]'])
+    assert_equal(4, @context['test[3]'])
+    assert_equal(5, @context['test[4]'])
   end
 
   def test_recoursive_array_notation
     @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
 
-    assert_equal 1, @context['test.test[0]']
+    assert_equal(1, @context['test.test[0]'])
 
     @context['test'] = [{ 'test' => 'worked' }]
 
-    assert_equal 'worked', @context['test[0].test']
+    assert_equal('worked', @context['test[0].test'])
   end
 
   def test_hash_to_array_transition
@@ -243,45 +243,45 @@ class ContextUnitTest < Minitest::Test
       'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
     }
 
-    assert_equal '003366', @context['colors.Blue[0]']
-    assert_equal 'FF9999', @context['colors.Red[3]']
+    assert_equal('003366', @context['colors.Blue[0]'])
+    assert_equal('FF9999', @context['colors.Red[3]'])
   end
 
   def test_try_first
     @context['test'] = [1, 2, 3, 4, 5]
 
-    assert_equal 1, @context['test.first']
-    assert_equal 5, @context['test.last']
+    assert_equal(1, @context['test.first'])
+    assert_equal(5, @context['test.last'])
 
     @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
 
-    assert_equal 1, @context['test.test.first']
-    assert_equal 5, @context['test.test.last']
+    assert_equal(1, @context['test.test.first'])
+    assert_equal(5, @context['test.test.last'])
 
     @context['test'] = [1]
-    assert_equal 1, @context['test.first']
-    assert_equal 1, @context['test.last']
+    assert_equal(1, @context['test.first'])
+    assert_equal(1, @context['test.last'])
   end
 
   def test_access_hashes_with_hash_notation
     @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
     @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
 
-    assert_equal 5, @context['products["count"]']
-    assert_equal 'deepsnow', @context['products["tags"][0]']
-    assert_equal 'deepsnow', @context['products["tags"].first']
-    assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
-    assert_equal 'element151cm', @context['product["variants"][1]["title"]']
-    assert_equal 'draft151cm', @context['product["variants"][0]["title"]']
-    assert_equal 'element151cm', @context['product["variants"].last["title"]']
+    assert_equal(5, @context['products["count"]'])
+    assert_equal('deepsnow', @context['products["tags"][0]'])
+    assert_equal('deepsnow', @context['products["tags"].first'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"][1]["title"]'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"].last["title"]'])
   end
 
   def test_access_variable_with_hash_notation
     @context['foo'] = 'baz'
     @context['bar'] = 'foo'
 
-    assert_equal 'baz', @context['["foo"]']
-    assert_equal 'baz', @context['[bar]']
+    assert_equal('baz', @context['["foo"]'])
+    assert_equal('baz', @context['[bar]'])
   end
 
   def test_access_hashes_with_hash_access_variables
@@ -289,119 +289,119 @@ class ContextUnitTest < Minitest::Test
     @context['nested'] = { 'var' => 'tags' }
     @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
 
-    assert_equal 'deepsnow', @context['products[var].first']
-    assert_equal 'freestyle', @context['products[nested.var].last']
+    assert_equal('deepsnow', @context['products[var].first'])
+    assert_equal('freestyle', @context['products[nested.var].last'])
   end
 
   def test_hash_notation_only_for_hash_access
     @context['array'] = [1, 2, 3, 4, 5]
     @context['hash'] = { 'first' => 'Hello' }
 
-    assert_equal 1, @context['array.first']
-    assert_nil @context['array["first"]']
-    assert_equal 'Hello', @context['hash["first"]']
+    assert_equal(1, @context['array.first'])
+    assert_nil(@context['array["first"]'])
+    assert_equal('Hello', @context['hash["first"]'])
   end
 
   def test_first_can_appear_in_middle_of_callchain
     @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
 
-    assert_equal 'draft151cm', @context['product.variants[0].title']
-    assert_equal 'element151cm', @context['product.variants[1].title']
-    assert_equal 'draft151cm', @context['product.variants.first.title']
-    assert_equal 'element151cm', @context['product.variants.last.title']
+    assert_equal('draft151cm', @context['product.variants[0].title'])
+    assert_equal('element151cm', @context['product.variants[1].title'])
+    assert_equal('draft151cm', @context['product.variants.first.title'])
+    assert_equal('element151cm', @context['product.variants.last.title'])
   end
 
   def test_cents
     @context.merge("cents" => HundredCentes.new)
-    assert_equal 100, @context['cents']
+    assert_equal(100, @context['cents'])
   end
 
   def test_nested_cents
     @context.merge("cents" => { 'amount' => HundredCentes.new })
-    assert_equal 100, @context['cents.amount']
+    assert_equal(100, @context['cents.amount'])
 
     @context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
-    assert_equal 100, @context['cents.cents.amount']
+    assert_equal(100, @context['cents.cents.amount'])
   end
 
   def test_cents_through_drop
     @context.merge("cents" => CentsDrop.new)
-    assert_equal 100, @context['cents.amount']
+    assert_equal(100, @context['cents.amount'])
   end
 
   def test_nested_cents_through_drop
     @context.merge("vars" => { "cents" => CentsDrop.new })
-    assert_equal 100, @context['vars.cents.amount']
+    assert_equal(100, @context['vars.cents.amount'])
   end
 
   def test_drop_methods_with_question_marks
     @context.merge("cents" => CentsDrop.new)
-    assert @context['cents.non_zero?']
+    assert(@context['cents.non_zero?'])
   end
 
   def test_context_from_within_drop
     @context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
-    assert_equal '123', @context['vars.test']
+    assert_equal('123', @context['vars.test'])
   end
 
   def test_nested_context_from_within_drop
     @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
-    assert_equal '123', @context['vars.local.test']
+    assert_equal('123', @context['vars.local.test'])
   end
 
   def test_ranges
     @context.merge("test" => '5')
-    assert_equal (1..5), @context['(1..5)']
-    assert_equal (1..5), @context['(1..test)']
-    assert_equal (5..5), @context['(test..test)']
+    assert_equal((1..5), @context['(1..5)'])
+    assert_equal((1..5), @context['(1..test)'])
+    assert_equal((5..5), @context['(test..test)'])
   end
 
   def test_cents_through_drop_nestedly
     @context.merge("cents" => { "cents" => CentsDrop.new })
-    assert_equal 100, @context['cents.cents.amount']
+    assert_equal(100, @context['cents.cents.amount'])
 
     @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
-    assert_equal 100, @context['cents.cents.cents.amount']
+    assert_equal(100, @context['cents.cents.cents.amount'])
   end
 
   def test_drop_with_variable_called_only_once
     @context['counter'] = CounterDrop.new
 
-    assert_equal 1, @context['counter.count']
-    assert_equal 2, @context['counter.count']
-    assert_equal 3, @context['counter.count']
+    assert_equal(1, @context['counter.count'])
+    assert_equal(2, @context['counter.count'])
+    assert_equal(3, @context['counter.count'])
   end
 
   def test_drop_with_key_called_only_once
     @context['counter'] = CounterDrop.new
 
-    assert_equal 1, @context['counter["count"]']
-    assert_equal 2, @context['counter["count"]']
-    assert_equal 3, @context['counter["count"]']
+    assert_equal(1, @context['counter["count"]'])
+    assert_equal(2, @context['counter["count"]'])
+    assert_equal(3, @context['counter["count"]'])
   end
 
   def test_proc_as_variable
     @context['dynamic'] = proc { 'Hello' }
 
-    assert_equal 'Hello', @context['dynamic']
+    assert_equal('Hello', @context['dynamic'])
   end
 
   def test_lambda_as_variable
     @context['dynamic'] = proc { 'Hello' }
 
-    assert_equal 'Hello', @context['dynamic']
+    assert_equal('Hello', @context['dynamic'])
   end
 
   def test_nested_lambda_as_variable
     @context['dynamic'] = { "lambda" => proc { 'Hello' } }
 
-    assert_equal 'Hello', @context['dynamic.lambda']
+    assert_equal('Hello', @context['dynamic.lambda'])
   end
 
   def test_array_containing_lambda_as_variable
     @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
 
-    assert_equal 'Hello', @context['dynamic[2]']
+    assert_equal('Hello', @context['dynamic[2]'])
   end
 
   def test_lambda_is_called_once
@@ -411,9 +411,9 @@ class ContextUnitTest < Minitest::Test
       @global.to_s
     }
 
-    assert_equal '1', @context['callcount']
-    assert_equal '1', @context['callcount']
-    assert_equal '1', @context['callcount']
+    assert_equal('1', @context['callcount'])
+    assert_equal('1', @context['callcount'])
+    assert_equal('1', @context['callcount'])
 
     @global = nil
   end
@@ -425,9 +425,9 @@ class ContextUnitTest < Minitest::Test
                                             @global.to_s
                                           } }
 
-    assert_equal '1', @context['callcount.lambda']
-    assert_equal '1', @context['callcount.lambda']
-    assert_equal '1', @context['callcount.lambda']
+    assert_equal('1', @context['callcount.lambda'])
+    assert_equal('1', @context['callcount.lambda'])
+    assert_equal('1', @context['callcount.lambda'])
 
     @global = nil
   end
@@ -439,9 +439,9 @@ class ContextUnitTest < Minitest::Test
                                      @global.to_s
                                    }, 4, 5]
 
-    assert_equal '1', @context['callcount[2]']
-    assert_equal '1', @context['callcount[2]']
-    assert_equal '1', @context['callcount[2]']
+    assert_equal('1', @context['callcount[2]'])
+    assert_equal('1', @context['callcount[2]'])
+    assert_equal('1', @context['callcount[2]'])
 
     @global = nil
   end
@@ -451,13 +451,13 @@ class ContextUnitTest < Minitest::Test
 
     @context['magic'] = proc { @context.registers[:magic] }
 
-    assert_equal 345392, @context['magic']
+    assert_equal(345392, @context['magic'])
   end
 
   def test_to_liquid_and_context_at_first_level
     @context['category'] = Category.new("foobar")
-    assert_kind_of CategoryDrop, @context['category']
-    assert_equal @context, @context['category'].context
+    assert_kind_of(CategoryDrop, @context['category'])
+    assert_equal(@context, @context['category'].context)
   end
 
   def test_interrupt_avoids_object_allocations
@@ -469,8 +469,8 @@ class ContextUnitTest < Minitest::Test
   def test_context_initialization_with_a_proc_in_environment
     contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo)
 
-    assert contx
-    assert_nil contx['poutine']
+    assert(contx)
+    assert_nil(contx['poutine'])
   end
 
   def test_apply_global_filter
@@ -479,7 +479,7 @@ class ContextUnitTest < Minitest::Test
     context = Context.new
     context.global_filter = global_filter_proc
 
-    assert_equal 'hi filtered', context.apply_global_filter('hi')
+    assert_equal('hi filtered', context.apply_global_filter('hi'))
   end
 
   def test_static_environments_are_read_with_lower_priority_than_environments
@@ -488,13 +488,13 @@ class ContextUnitTest < Minitest::Test
       environments: { 'shadowed' => 'dynamic' }
     )
 
-    assert_equal 'dynamic', context['shadowed']
-    assert_equal 'static', context['unshadowed']
+    assert_equal('dynamic', context['shadowed'])
+    assert_equal('static', context['unshadowed'])
   end
 
   def test_apply_global_filter_when_no_global_filter_exist
     context = Context.new
-    assert_equal 'hi', context.apply_global_filter('hi')
+    assert_equal('hi', context.apply_global_filter('hi'))
   end
 
   def test_new_isolated_subcontext_does_not_inherit_variables
@@ -502,28 +502,28 @@ class ContextUnitTest < Minitest::Test
     super_context['my_variable'] = 'some value'
     subcontext = super_context.new_isolated_subcontext
 
-    assert_nil subcontext['my_variable']
+    assert_nil(subcontext['my_variable'])
   end
 
   def test_new_isolated_subcontext_inherits_static_environment
     super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
     subcontext = super_context.new_isolated_subcontext
 
-    assert_equal 'my value', subcontext['my_environment_value']
+    assert_equal('my value', subcontext['my_environment_value'])
   end
 
   def test_new_isolated_subcontext_inherits_resource_limits
     resource_limits = ResourceLimits.new({})
     super_context = Context.new({}, {}, {}, false, resource_limits)
     subcontext = super_context.new_isolated_subcontext
-    assert_equal resource_limits, subcontext.resource_limits
+    assert_equal(resource_limits, subcontext.resource_limits)
   end
 
   def test_new_isolated_subcontext_inherits_exception_renderer
     super_context = Context.new
     super_context.exception_renderer = ->(_e) { 'my exception message' }
     subcontext = super_context.new_isolated_subcontext
-    assert_equal 'my exception message', subcontext.handle_error(Liquid::Error.new)
+    assert_equal('my exception message', subcontext.handle_error(Liquid::Error.new))
   end
 
   def test_new_isolated_subcontext_does_not_inherit_non_static_registers
@@ -533,20 +533,20 @@ class ContextUnitTest < Minitest::Test
     super_context = Context.new({}, {}, StaticRegisters.new(registers))
     super_context.registers[:my_register] = :my_alt_value
     subcontext = super_context.new_isolated_subcontext
-    assert_equal :my_value, subcontext.registers[:my_register]
+    assert_equal(:my_value, subcontext.registers[:my_register])
   end
 
   def test_new_isolated_subcontext_inherits_static_registers
     super_context = Context.build(registers: { my_register: :my_value })
     subcontext = super_context.new_isolated_subcontext
-    assert_equal :my_value, subcontext.registers[:my_register]
+    assert_equal(:my_value, subcontext.registers[:my_register])
   end
 
   def test_new_isolated_subcontext_registers_do_not_pollute_context
     super_context = Context.build(registers: { my_register: :my_value })
     subcontext = super_context.new_isolated_subcontext
     subcontext.registers[:my_register] = :my_alt_value
-    assert_equal :my_value, super_context.registers[:my_register]
+    assert_equal(:my_value, super_context.registers[:my_register])
   end
 
   def test_new_isolated_subcontext_inherits_filters
@@ -560,20 +560,20 @@ class ContextUnitTest < Minitest::Test
     super_context.add_filters([my_filter])
     subcontext = super_context.new_isolated_subcontext
     template = Template.parse('{{ 123 | my_filter }}')
-    assert_equal 'my filter result', template.render(subcontext)
+    assert_equal('my filter result', template.render(subcontext))
   end
 
   private
 
   def assert_no_object_allocations
     unless RUBY_ENGINE == 'ruby'
-      skip "stackprof needed to count object allocations"
+      skip("stackprof needed to count object allocations")
     end
     require 'stackprof'
 
     profile = StackProf.run(mode: :object) do
       yield
     end
-    assert_equal 0, profile[:samples]
+    assert_equal(0, profile[:samples])
   end
 end # ContextTest

test/unit/file_system_unit_test.rb

@@ -13,8 +13,8 @@ class FileSystemUnitTest < Minitest::Test
 
   def test_local
     file_system = Liquid::LocalFileSystem.new("/some/path")
-    assert_equal "/some/path/_mypartial.liquid", file_system.full_path("mypartial")
-    assert_equal "/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial")
+    assert_equal("/some/path/_mypartial.liquid", file_system.full_path("mypartial"))
+    assert_equal("/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial"))
 
     assert_raises(FileSystemError) do
       file_system.full_path("../dir/mypartial")
@@ -31,7 +31,7 @@ class FileSystemUnitTest < Minitest::Test
 
   def test_custom_template_filename_patterns
     file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
-    assert_equal "/some/path/mypartial.html", file_system.full_path("mypartial")
-    assert_equal "/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial")
+    assert_equal("/some/path/mypartial.html", file_system.full_path("mypartial"))
+    assert_equal("/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial"))
   end
 end # FileSystemTest

test/unit/i18n_unit_test.rb

@@ -10,15 +10,15 @@ class I18nUnitTest < Minitest::Test
   end
 
   def test_simple_translate_string
-    assert_equal "less is more", @i18n.translate("simple")
+    assert_equal("less is more", @i18n.translate("simple"))
   end
 
   def test_nested_translate_string
-    assert_equal "something wasn't right", @i18n.translate("errors.syntax.oops")
+    assert_equal("something wasn't right", @i18n.translate("errors.syntax.oops"))
   end
 
   def test_single_string_interpolation
-    assert_equal "something different", @i18n.translate("whatever", something: "different")
+    assert_equal("something different", @i18n.translate("whatever", something: "different"))
   end
 
   # def test_raises_translation_error_on_undefined_interpolation_key
@@ -34,6 +34,6 @@ class I18nUnitTest < Minitest::Test
   end
 
   def test_sets_default_path_to_en
-    assert_equal I18n::DEFAULT_LOCALE, I18n.new.path
+    assert_equal(I18n::DEFAULT_LOCALE, I18n.new.path)
   end
 end

test/unit/lexer_unit_test.rb

@@ -7,42 +7,42 @@ class LexerUnitTest < Minitest::Test
 
   def test_strings
     tokens = Lexer.new(%( 'this is a test""' "wat 'lol'")).tokenize
-    assert_equal [[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]], tokens
+    assert_equal([[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]], tokens)
   end
 
   def test_integer
     tokens = Lexer.new('hi 50').tokenize
-    assert_equal [[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens
+    assert_equal([[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens)
   end
 
   def test_float
     tokens = Lexer.new('hi 5.0').tokenize
-    assert_equal [[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens
+    assert_equal([[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens)
   end
 
   def test_comparison
     tokens = Lexer.new('== <> contains ').tokenize
-    assert_equal [[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens
+    assert_equal([[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens)
   end
 
   def test_specials
     tokens = Lexer.new('| .:').tokenize
-    assert_equal [[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]], tokens
+    assert_equal([[:pipe, '|'], [:dot, '.'], [:colon, ':'], [:end_of_string]], tokens)
     tokens = Lexer.new('[,]').tokenize
-    assert_equal [[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]], tokens
+    assert_equal([[:open_square, '['], [:comma, ','], [:close_square, ']'], [:end_of_string]], tokens)
   end
 
   def test_fancy_identifiers
     tokens = Lexer.new('hi five?').tokenize
-    assert_equal [[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens
+    assert_equal([[:id, 'hi'], [:id, 'five?'], [:end_of_string]], tokens)
 
     tokens = Lexer.new('2foo').tokenize
-    assert_equal [[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens
+    assert_equal([[:number, '2'], [:id, 'foo'], [:end_of_string]], tokens)
   end
 
   def test_whitespace
     tokens = Lexer.new("five|\n\t ==").tokenize
-    assert_equal [[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens
+    assert_equal([[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens)
   end
 
   def test_unexpected_character

test/unit/parser_unit_test.rb

@@ -7,72 +7,72 @@ class ParserUnitTest < Minitest::Test
 
   def test_consume
     p = Parser.new("wat: 7")
-    assert_equal 'wat', p.consume(:id)
-    assert_equal ':', p.consume(:colon)
-    assert_equal '7', p.consume(:number)
+    assert_equal('wat', p.consume(:id))
+    assert_equal(':', p.consume(:colon))
+    assert_equal('7', p.consume(:number))
   end
 
   def test_jump
     p = Parser.new("wat: 7")
     p.jump(2)
-    assert_equal '7', p.consume(:number)
+    assert_equal('7', p.consume(:number))
   end
 
   def test_consume?
     p = Parser.new("wat: 7")
-    assert_equal 'wat', p.consume?(:id)
-    assert_equal false, p.consume?(:dot)
-    assert_equal ':', p.consume(:colon)
-    assert_equal '7', p.consume?(:number)
+    assert_equal('wat', p.consume?(:id))
+    assert_equal(false, p.consume?(:dot))
+    assert_equal(':', p.consume(:colon))
+    assert_equal('7', p.consume?(:number))
   end
 
   def test_id?
     p = Parser.new("wat 6 Peter Hegemon")
-    assert_equal 'wat', p.id?('wat')
-    assert_equal false, p.id?('endgame')
-    assert_equal '6', p.consume(:number)
-    assert_equal 'Peter', p.id?('Peter')
-    assert_equal false, p.id?('Achilles')
+    assert_equal('wat', p.id?('wat'))
+    assert_equal(false, p.id?('endgame'))
+    assert_equal('6', p.consume(:number))
+    assert_equal('Peter', p.id?('Peter'))
+    assert_equal(false, p.id?('Achilles'))
   end
 
   def test_look
     p = Parser.new("wat 6 Peter Hegemon")
-    assert_equal true, p.look(:id)
-    assert_equal 'wat', p.consume(:id)
-    assert_equal false, p.look(:comparison)
-    assert_equal true, p.look(:number)
-    assert_equal true, p.look(:id, 1)
-    assert_equal false, p.look(:number, 1)
+    assert_equal(true, p.look(:id))
+    assert_equal('wat', p.consume(:id))
+    assert_equal(false, p.look(:comparison))
+    assert_equal(true, p.look(:number))
+    assert_equal(true, p.look(:id, 1))
+    assert_equal(false, p.look(:number, 1))
   end
 
   def test_expressions
     p = Parser.new("hi.there hi?[5].there? hi.there.bob")
-    assert_equal 'hi.there', p.expression
-    assert_equal 'hi?[5].there?', p.expression
-    assert_equal 'hi.there.bob', p.expression
+    assert_equal('hi.there', p.expression)
+    assert_equal('hi?[5].there?', p.expression)
+    assert_equal('hi.there.bob', p.expression)
 
     p = Parser.new("567 6.0 'lol' \"wut\"")
-    assert_equal '567', p.expression
-    assert_equal '6.0', p.expression
-    assert_equal "'lol'", p.expression
-    assert_equal '"wut"', p.expression
+    assert_equal('567', p.expression)
+    assert_equal('6.0', p.expression)
+    assert_equal("'lol'", p.expression)
+    assert_equal('"wut"', p.expression)
   end
 
   def test_ranges
     p = Parser.new("(5..7) (1.5..9.6) (young..old) (hi[5].wat..old)")
-    assert_equal '(5..7)', p.expression
-    assert_equal '(1.5..9.6)', p.expression
-    assert_equal '(young..old)', p.expression
-    assert_equal '(hi[5].wat..old)', p.expression
+    assert_equal('(5..7)', p.expression)
+    assert_equal('(1.5..9.6)', p.expression)
+    assert_equal('(young..old)', p.expression)
+    assert_equal('(hi[5].wat..old)', p.expression)
   end
 
   def test_arguments
     p = Parser.new("filter: hi.there[5], keyarg: 7")
-    assert_equal 'filter', p.consume(:id)
-    assert_equal ':', p.consume(:colon)
-    assert_equal 'hi.there[5]', p.argument
-    assert_equal ',', p.consume(:comma)
-    assert_equal 'keyarg: 7', p.argument
+    assert_equal('filter', p.consume(:id))
+    assert_equal(':', p.consume(:colon))
+    assert_equal('hi.there[5]', p.argument)
+    assert_equal(',', p.consume(:comma))
+    assert_equal('keyarg: 7', p.argument)
   end
 
   def test_invalid_expression

test/unit/partial_cache_unit_test.rb

@@ -16,7 +16,7 @@ class PartialCacheUnitTest < Minitest::Test
       parse_context: Liquid::ParseContext.new
     )
 
-    assert_equal 'my partial body', partial.render
+    assert_equal('my partial body', partial.render)
   end
 
   def test_reads_from_the_file_system_only_once_per_file
@@ -33,7 +33,7 @@ class PartialCacheUnitTest < Minitest::Test
       )
     end
 
-    assert_equal 1, file_system.file_read_count
+    assert_equal(1, file_system.file_read_count)
   end
 
   def test_cache_state_is_stored_per_context
@@ -66,7 +66,7 @@ class PartialCacheUnitTest < Minitest::Test
       parse_context: parse_context
     )
 
-    assert_equal 2, shared_file_system.file_read_count
+    assert_equal(2, shared_file_system.file_read_count)
   end
 
   def test_cache_is_not_broken_when_a_different_parse_context_is_used
@@ -88,6 +88,6 @@ class PartialCacheUnitTest < Minitest::Test
 
     # Technically what we care about is that the file was parsed twice,
     # but measuring file reads is an OK proxy for this.
-    assert_equal 1, file_system.file_read_count
+    assert_equal(1, file_system.file_read_count)
   end
 end

test/unit/regexp_unit_test.rb

@@ -6,41 +6,41 @@ class RegexpUnitTest < Minitest::Test
   include Liquid
 
   def test_empty
-    assert_equal [], ''.scan(QuotedFragment)
+    assert_equal([], ''.scan(QuotedFragment))
   end
 
   def test_quote
-    assert_equal ['"arg 1"'], '"arg 1"'.scan(QuotedFragment)
+    assert_equal(['"arg 1"'], '"arg 1"'.scan(QuotedFragment))
   end
 
   def test_words
-    assert_equal ['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment)
+    assert_equal(['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment))
   end
 
   def test_tags
-    assert_equal ['<tr>', '</tr>'], '<tr> </tr>'.scan(QuotedFragment)
-    assert_equal ['<tr></tr>'], '<tr></tr>'.scan(QuotedFragment)
-    assert_equal ['<style', 'class="hello">', '</style>'], %(<style class="hello">' </style>).scan(QuotedFragment)
+    assert_equal(['<tr>', '</tr>'], '<tr> </tr>'.scan(QuotedFragment))
+    assert_equal(['<tr></tr>'], '<tr></tr>'.scan(QuotedFragment))
+    assert_equal(['<style', 'class="hello">', '</style>'], %(<style class="hello">' </style>).scan(QuotedFragment))
   end
 
   def test_double_quoted_words
-    assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment)
+    assert_equal(['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment))
   end
 
   def test_single_quoted_words
-    assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment)
+    assert_equal(['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment))
   end
 
   def test_quoted_words_in_the_middle
-    assert_equal ['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4   '.scan(QuotedFragment)
+    assert_equal(['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4   '.scan(QuotedFragment))
   end
 
   def test_variable_parser
-    assert_equal ['var'],                               'var'.scan(VariableParser)
-    assert_equal ['var', 'method'],                     'var.method'.scan(VariableParser)
-    assert_equal ['var', '[method]'],                   'var[method]'.scan(VariableParser)
-    assert_equal ['var', '[method]', '[0]'],            'var[method][0]'.scan(VariableParser)
-    assert_equal ['var', '["method"]', '[0]'],          'var["method"][0]'.scan(VariableParser)
-    assert_equal ['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser)
+    assert_equal(['var'],                               'var'.scan(VariableParser))
+    assert_equal(['var', 'method'],                     'var.method'.scan(VariableParser))
+    assert_equal(['var', '[method]'],                   'var[method]'.scan(VariableParser))
+    assert_equal(['var', '[method]', '[0]'],            'var[method][0]'.scan(VariableParser))
+    assert_equal(['var', '["method"]', '[0]'],          'var["method"][0]'.scan(VariableParser))
+    assert_equal(['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser))
   end
 end # RegexpTest

test/unit/registers/disabled_tags_unit_test.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class DisabledTagsUnitTest < Minitest::Test
+  include Liquid
+
+  def test_disables_tag_specified
+    register = DisabledTags.new
+    register.disable(%w(foo bar)) do
+      assert_equal true, register.disabled?("foo")
+      assert_equal true, register.disabled?("bar")
+      assert_equal false, register.disabled?("unknown")
+    end
+  end
+
+  def test_disables_nested_tags
+    register = DisabledTags.new
+    register.disable(["foo"]) do
+      register.disable(["foo"]) do
+        assert_equal true, register.disabled?("foo")
+        assert_equal false, register.disabled?("bar")
+      end
+      register.disable(["bar"]) do
+        assert_equal true, register.disabled?("foo")
+        assert_equal true, register.disabled?("bar")
+        register.disable(["foo"]) do
+          assert_equal true, register.disabled?("foo")
+          assert_equal true, register.disabled?("bar")
+        end
+      end
+      assert_equal true, register.disabled?("foo")
+      assert_equal false, register.disabled?("bar")
+    end
+  end
+end

test/unit/static_registers_unit_test.rb

@@ -22,23 +22,23 @@ class StaticRegistersUnitTest < Minitest::Test
   def test_get
     static_register = set
 
-    assert_equal true, static_register[nil]
-    assert_equal :one, static_register[1]
-    assert_equal "one", static_register[:one]
-    assert_equal 3, static_register["two"]
-    assert_nil static_register[false]
-    assert_nil static_register["unknown"]
+    assert_equal(true, static_register[nil])
+    assert_equal(:one, static_register[1])
+    assert_equal("one", static_register[:one])
+    assert_equal(3, static_register["two"])
+    assert_nil(static_register[false])
+    assert_nil(static_register["unknown"])
   end
 
   def test_delete
     static_register = set
 
-    assert_equal true, static_register.delete(nil)
-    assert_equal :one, static_register.delete(1)
-    assert_equal "one", static_register.delete(:one)
-    assert_equal 3, static_register.delete("two")
-    assert_nil static_register.delete(false)
-    assert_nil static_register.delete("unknown")
+    assert_equal(true, static_register.delete(nil))
+    assert_equal(:one, static_register.delete(1))
+    assert_equal("one", static_register.delete(:one))
+    assert_equal(3, static_register.delete("two"))
+    assert_nil(static_register.delete(false))
+    assert_nil(static_register.delete("unknown"))
 
     assert_equal({}, static_register.registers)
   end
@@ -46,34 +46,34 @@ class StaticRegistersUnitTest < Minitest::Test
   def test_fetch
     static_register = set
 
-    assert_equal true, static_register.fetch(nil)
-    assert_equal :one, static_register.fetch(1)
-    assert_equal "one", static_register.fetch(:one)
-    assert_equal 3, static_register.fetch("two")
-    assert_nil static_register.fetch(false)
-    assert_nil static_register.fetch("unknown")
+    assert_equal(true, static_register.fetch(nil))
+    assert_equal(:one, static_register.fetch(1))
+    assert_equal("one", static_register.fetch(:one))
+    assert_equal(3, static_register.fetch("two"))
+    assert_nil(static_register.fetch(false))
+    assert_nil(static_register.fetch("unknown"))
   end
 
   def test_fetch_default
     static_register = StaticRegisters.new
 
-    assert_equal true, static_register.fetch(nil, true)
-    assert_equal :one, static_register.fetch(1, :one)
-    assert_equal "one", static_register.fetch(:one, "one")
-    assert_equal 3, static_register.fetch("two", 3)
-    assert_nil static_register.fetch(false, nil)
+    assert_equal(true, static_register.fetch(nil, true))
+    assert_equal(:one, static_register.fetch(1, :one))
+    assert_equal("one", static_register.fetch(:one, "one"))
+    assert_equal(3, static_register.fetch("two", 3))
+    assert_nil(static_register.fetch(false, nil))
   end
 
   def test_key
     static_register = set
 
-    assert_equal true, static_register.key?(nil)
-    assert_equal true, static_register.key?(1)
-    assert_equal true, static_register.key?(:one)
-    assert_equal true, static_register.key?("two")
-    assert_equal true, static_register.key?(false)
-    assert_equal false, static_register.key?("unknown")
-    assert_equal false, static_register.key?(true)
+    assert_equal(true, static_register.key?(nil))
+    assert_equal(true, static_register.key?(1))
+    assert_equal(true, static_register.key?(:one))
+    assert_equal(true, static_register.key?("two"))
+    assert_equal(true, static_register.key?(false))
+    assert_equal(false, static_register.key?("unknown"))
+    assert_equal(false, static_register.key?(true))
   end
 
   def set_with_static
@@ -91,22 +91,22 @@ class StaticRegistersUnitTest < Minitest::Test
   def test_get_with_static
     static_register = set_with_static
 
-    assert_equal false, static_register[nil]
-    assert_equal :one, static_register[1]
-    assert_equal "one", static_register[:one]
-    assert_equal 4, static_register["two"]
-    assert_equal "foo", static_register[true]
-    assert_nil static_register[false]
+    assert_equal(false, static_register[nil])
+    assert_equal(:one, static_register[1])
+    assert_equal("one", static_register[:one])
+    assert_equal(4, static_register["two"])
+    assert_equal("foo", static_register[true])
+    assert_nil(static_register[false])
   end
 
   def test_delete_with_static
     static_register = set_with_static
 
-    assert_equal false, static_register.delete(nil)
-    assert_equal 4, static_register.delete("two")
-    assert_equal "foo", static_register.delete(true)
-    assert_nil static_register.delete("unknown")
-    assert_nil static_register.delete(:one)
+    assert_equal(false, static_register.delete(nil))
+    assert_equal(4, static_register.delete("two"))
+    assert_equal("foo", static_register.delete(true))
+    assert_nil(static_register.delete("unknown"))
+    assert_nil(static_register.delete(:one))
 
     assert_equal({}, static_register.registers)
     assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
@@ -115,24 +115,24 @@ class StaticRegistersUnitTest < Minitest::Test
   def test_fetch_with_static
     static_register = set_with_static
 
-    assert_equal false, static_register.fetch(nil)
-    assert_equal :one, static_register.fetch(1)
-    assert_equal "one", static_register.fetch(:one)
-    assert_equal 4, static_register.fetch("two")
-    assert_equal "foo", static_register.fetch(true)
-    assert_nil static_register.fetch(false)
+    assert_equal(false, static_register.fetch(nil))
+    assert_equal(:one, static_register.fetch(1))
+    assert_equal("one", static_register.fetch(:one))
+    assert_equal(4, static_register.fetch("two"))
+    assert_equal("foo", static_register.fetch(true))
+    assert_nil(static_register.fetch(false))
   end
 
   def test_key_with_static
     static_register = set_with_static
 
-    assert_equal true, static_register.key?(nil)
-    assert_equal true, static_register.key?(1)
-    assert_equal true, static_register.key?(:one)
-    assert_equal true, static_register.key?("two")
-    assert_equal true, static_register.key?(false)
-    assert_equal false, static_register.key?("unknown")
-    assert_equal true, static_register.key?(true)
+    assert_equal(true, static_register.key?(nil))
+    assert_equal(true, static_register.key?(1))
+    assert_equal(true, static_register.key?(:one))
+    assert_equal(true, static_register.key?("two"))
+    assert_equal(true, static_register.key?(false))
+    assert_equal(false, static_register.key?("unknown"))
+    assert_equal(true, static_register.key?(true))
   end
 
   def test_static_register_can_be_frozen

test/unit/strainer_unit_test.rb

@@ -20,8 +20,8 @@ class StrainerUnitTest < Minitest::Test
 
   def test_strainer
     strainer = Strainer.create(nil)
-    assert_equal 5, strainer.invoke('size', 'input')
-    assert_equal "public", strainer.invoke("public_filter")
+    assert_equal(5, strainer.invoke('size', 'input'))
+    assert_equal("public", strainer.invoke("public_filter"))
   end
 
   def test_stainer_raises_argument_error
@@ -40,45 +40,45 @@ class StrainerUnitTest < Minitest::Test
         /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/,
         e.message
       )
-      assert_equal e.backtrace[0].split(':')[0], __FILE__
+      assert_equal(e.backtrace[0].split(':')[0], __FILE__)
     end
   end
 
   def test_strainer_only_invokes_public_filter_methods
     strainer = Strainer.create(nil)
-    assert_equal false, strainer.class.invokable?('__test__')
-    assert_equal false, strainer.class.invokable?('test')
-    assert_equal false, strainer.class.invokable?('instance_eval')
-    assert_equal false, strainer.class.invokable?('__send__')
-    assert_equal true, strainer.class.invokable?('size') # from the standard lib
+    assert_equal(false, strainer.class.invokable?('__test__'))
+    assert_equal(false, strainer.class.invokable?('test'))
+    assert_equal(false, strainer.class.invokable?('instance_eval'))
+    assert_equal(false, strainer.class.invokable?('__send__'))
+    assert_equal(true, strainer.class.invokable?('size')) # from the standard lib
   end
 
   def test_strainer_returns_nil_if_no_filter_method_found
     strainer = Strainer.create(nil)
-    assert_nil strainer.invoke("private_filter")
-    assert_nil strainer.invoke("undef_the_filter")
+    assert_nil(strainer.invoke("private_filter"))
+    assert_nil(strainer.invoke("undef_the_filter"))
   end
 
   def test_strainer_returns_first_argument_if_no_method_and_arguments_given
     strainer = Strainer.create(nil)
-    assert_equal "password", strainer.invoke("undef_the_method", "password")
+    assert_equal("password", strainer.invoke("undef_the_method", "password"))
   end
 
   def test_strainer_only_allows_methods_defined_in_filters
     strainer = Strainer.create(nil)
-    assert_equal "1 + 1", strainer.invoke("instance_eval", "1 + 1")
-    assert_equal "puts",  strainer.invoke("__send__", "puts", "Hi Mom")
-    assert_equal "has_method?", strainer.invoke("invoke", "has_method?", "invoke")
+    assert_equal("1 + 1", strainer.invoke("instance_eval", "1 + 1"))
+    assert_equal("puts",  strainer.invoke("__send__", "puts", "Hi Mom"))
+    assert_equal("has_method?", strainer.invoke("invoke", "has_method?", "invoke"))
   end
 
   def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
     a = Module.new
     b = Module.new
     strainer = Strainer.create(nil, [a, b])
-    assert_kind_of Strainer, strainer
-    assert_kind_of a, strainer
-    assert_kind_of b, strainer
-    assert_kind_of Liquid::StandardFilters, strainer
+    assert_kind_of(Strainer, strainer)
+    assert_kind_of(a, strainer)
+    assert_kind_of(b, strainer)
+    assert_kind_of(Liquid::StandardFilters, strainer)
   end
 
   def test_add_filter_when_wrong_filter_class
@@ -105,7 +105,7 @@ class StrainerUnitTest < Minitest::Test
     error = assert_raises(Liquid::MethodOverrideError) do
       strainer.class.add_filter(PrivateMethodOverrideFilter)
     end
-    assert_equal 'Liquid error: Filter overrides registered public methods as non public: public_filter', error.message
+    assert_equal('Liquid error: Filter overrides registered public methods as non public: public_filter', error.message)
   end
 
   module ProtectedMethodOverrideFilter
@@ -122,7 +122,7 @@ class StrainerUnitTest < Minitest::Test
     error = assert_raises(Liquid::MethodOverrideError) do
       strainer.class.add_filter(ProtectedMethodOverrideFilter)
     end
-    assert_equal 'Liquid error: Filter overrides registered public methods as non public: public_filter', error.message
+    assert_equal('Liquid error: Filter overrides registered public methods as non public: public_filter', error.message)
   end
 
   module PublicMethodOverrideFilter
@@ -134,7 +134,7 @@ class StrainerUnitTest < Minitest::Test
   def test_add_filter_does_not_raise_when_module_overrides_previously_registered_method
     strainer = Context.new.strainer
     strainer.class.add_filter(PublicMethodOverrideFilter)
-    assert strainer.class.filter_methods.include?('public_filter')
+    assert(strainer.class.filter_methods.include?('public_filter'))
   end
 
   module LateAddedFilter
@@ -144,9 +144,9 @@ class StrainerUnitTest < Minitest::Test
   end
 
   def test_global_filter_clears_cache
-    assert_equal 'input', Strainer.create(nil).invoke('late_added_filter', 'input')
+    assert_equal('input', Strainer.create(nil).invoke('late_added_filter', 'input'))
     Strainer.global_filter(LateAddedFilter)
-    assert_equal 'filtered', Strainer.create(nil).invoke('late_added_filter', 'input')
+    assert_equal('filtered', Strainer.create(nil).invoke('late_added_filter', 'input'))
   end
 
   def test_add_filter_does_not_include_already_included_module
@@ -162,6 +162,6 @@ class StrainerUnitTest < Minitest::Test
     strainer = Context.new.strainer
     strainer.class.add_filter(mod)
     strainer.class.add_filter(mod)
-    assert_equal 1, mod.include_count
+    assert_equal(1, mod.include_count)
   end
 end # StrainerTest

test/unit/tag_unit_test.rb

@@ -7,8 +7,8 @@ class TagUnitTest < Minitest::Test
 
   def test_tag
     tag = Tag.parse('tag', "", Tokenizer.new(""), ParseContext.new)
-    assert_equal 'liquid::tag', tag.name
-    assert_equal '', tag.render(Context.new)
+    assert_equal('liquid::tag', tag.name)
+    assert_equal('', tag.render(Context.new))
   end
 
   def test_return_raw_text_of_tag
@@ -18,7 +18,7 @@ class TagUnitTest < Minitest::Test
 
   def test_tag_name_should_return_name_of_the_tag
     tag = Tag.parse("some_tag", "", Tokenizer.new(""), ParseContext.new)
-    assert_equal 'some_tag', tag.tag_name
+    assert_equal('some_tag', tag.tag_name)
   end
 
   def test_custom_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility

test/unit/tags/case_tag_unit_test.rb

@@ -7,6 +7,6 @@ class CaseTagUnitTest < Minitest::Test
 
   def test_case_nodelist
     template = Liquid::Template.parse('{% case var %}{% when true %}WHEN{% else %}ELSE{% endcase %}')
-    assert_equal ['WHEN', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+    assert_equal(['WHEN', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten)
   end
 end

test/unit/tags/for_tag_unit_test.rb

@@ -5,11 +5,11 @@ require 'test_helper'
 class ForTagUnitTest < Minitest::Test
   def test_for_nodelist
     template = Liquid::Template.parse('{% for item in items %}FOR{% endfor %}')
-    assert_equal ['FOR'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+    assert_equal(['FOR'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten)
   end
 
   def test_for_else_nodelist
     template = Liquid::Template.parse('{% for item in items %}FOR{% else %}ELSE{% endfor %}')
-    assert_equal ['FOR', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten
+    assert_equal(['FOR', 'ELSE'], template.root.nodelist[0].nodelist.map(&:nodelist).flatten)
   end
 end

test/unit/template_unit_test.rb

@@ -8,7 +8,7 @@ class TemplateUnitTest < Minitest::Test
   def test_sets_default_localization_in_document
     t = Template.new
     t.parse('{%comment%}{%endcomment%}')
-    assert_instance_of I18n, t.root.nodelist[0].options[:locale]
+    assert_instance_of(I18n, t.root.nodelist[0].options[:locale])
   end
 
   def test_sets_default_localization_in_context_with_quick_initialization
@@ -16,8 +16,8 @@ class TemplateUnitTest < Minitest::Test
     t.parse('{%comment%}{%endcomment%}', locale: I18n.new(fixture("en_locale.yml")))
 
     locale = t.root.nodelist[0].options[:locale]
-    assert_instance_of I18n, locale
-    assert_equal fixture("en_locale.yml"), locale.path
+    assert_instance_of(I18n, locale)
+    assert_equal(fixture("en_locale.yml"), locale.path)
   end
 
   def test_with_cache_classes_tags_returns_the_same_class
@@ -33,7 +33,7 @@ class TemplateUnitTest < Minitest::Test
     new_klass = Class.new
     Object.send(:const_set, :CustomTag, new_klass)
 
-    assert Template.tags['custom'].equal?(original_klass)
+    assert(Template.tags['custom'].equal?(original_klass))
   ensure
     Object.send(:remove_const, :CustomTag)
     Template.tags.delete('custom')
@@ -53,7 +53,7 @@ class TemplateUnitTest < Minitest::Test
     new_klass = Class.new
     Object.send(:const_set, :CustomTag, new_klass)
 
-    assert Template.tags['custom'].equal?(new_klass)
+    assert(Template.tags['custom'].equal?(new_klass))
   ensure
     Object.send(:remove_const, :CustomTag)
     Template.tags.delete('custom')
@@ -64,16 +64,16 @@ class TemplateUnitTest < Minitest::Test
 
   def test_tags_delete
     Template.register_tag('fake', FakeTag)
-    assert_equal FakeTag, Template.tags['fake']
+    assert_equal(FakeTag, Template.tags['fake'])
 
     Template.tags.delete('fake')
-    assert_nil Template.tags['fake']
+    assert_nil(Template.tags['fake'])
   end
 
   def test_tags_can_be_looped_over
     Template.register_tag('fake', FakeTag)
     result = Template.tags.map { |name, klass| [name, klass] }
-    assert result.include?(["fake", "TemplateUnitTest::FakeTag"])
+    assert(result.include?(["fake", "TemplateUnitTest::FakeTag"]))
   ensure
     Template.tags.delete('fake')
   end

test/unit/tokenizer_unit_test.rb

@@ -4,30 +4,30 @@ require 'test_helper'
 
 class TokenizerTest < Minitest::Test
   def test_tokenize_strings
-    assert_equal [' '], tokenize(' ')
-    assert_equal ['hello world'], tokenize('hello world')
+    assert_equal([' '], tokenize(' '))
+    assert_equal(['hello world'], tokenize('hello world'))
   end
 
   def test_tokenize_variables
-    assert_equal ['{{funk}}'], tokenize('{{funk}}')
-    assert_equal [' ', '{{funk}}', ' '], tokenize(' {{funk}} ')
-    assert_equal [' ', '{{funk}}', ' ', '{{so}}', ' ', '{{brother}}', ' '], tokenize(' {{funk}} {{so}} {{brother}} ')
-    assert_equal [' ', '{{  funk  }}', ' '], tokenize(' {{  funk  }} ')
+    assert_equal(['{{funk}}'], tokenize('{{funk}}'))
+    assert_equal([' ', '{{funk}}', ' '], tokenize(' {{funk}} '))
+    assert_equal([' ', '{{funk}}', ' ', '{{so}}', ' ', '{{brother}}', ' '], tokenize(' {{funk}} {{so}} {{brother}} '))
+    assert_equal([' ', '{{  funk  }}', ' '], tokenize(' {{  funk  }} '))
   end
 
   def test_tokenize_blocks
-    assert_equal ['{%comment%}'], tokenize('{%comment%}')
-    assert_equal [' ', '{%comment%}', ' '], tokenize(' {%comment%} ')
+    assert_equal(['{%comment%}'], tokenize('{%comment%}'))
+    assert_equal([' ', '{%comment%}', ' '], tokenize(' {%comment%} '))
 
-    assert_equal [' ', '{%comment%}', ' ', '{%endcomment%}', ' '], tokenize(' {%comment%} {%endcomment%} ')
-    assert_equal ['  ', '{% comment %}', ' ', '{% endcomment %}', ' '], tokenize("  {% comment %} {% endcomment %} ")
+    assert_equal([' ', '{%comment%}', ' ', '{%endcomment%}', ' '], tokenize(' {%comment%} {%endcomment%} '))
+    assert_equal(['  ', '{% comment %}', ' ', '{% endcomment %}', ' '], tokenize("  {% comment %} {% endcomment %} "))
   end
 
   def test_calculate_line_numbers_per_token_with_profiling
-    assert_equal [1],       tokenize_line_numbers("{{funk}}")
-    assert_equal [1, 1, 1], tokenize_line_numbers(" {{funk}} ")
-    assert_equal [1, 2, 2], tokenize_line_numbers("\n{{funk}}\n")
-    assert_equal [1, 1, 3], tokenize_line_numbers(" {{\n funk \n}} ")
+    assert_equal([1],       tokenize_line_numbers("{{funk}}"))
+    assert_equal([1, 1, 1], tokenize_line_numbers(" {{funk}} "))
+    assert_equal([1, 2, 2], tokenize_line_numbers("\n{{funk}}\n"))
+    assert_equal([1, 1, 3], tokenize_line_numbers(" {{\n funk \n}} "))
   end
 
   private

test/unit/variable_unit_test.rb

@@ -7,106 +7,106 @@ class VariableUnitTest < Minitest::Test
 
   def test_variable
     var = create_variable('hello')
-    assert_equal VariableLookup.new('hello'), var.name
+    assert_equal(VariableLookup.new('hello'), var.name)
   end
 
   def test_filters
     var = create_variable('hello | textileze')
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze', []]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['textileze', []]], var.filters)
 
     var = create_variable('hello | textileze | paragraph')
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze', []], ['paragraph', []]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable(%( hello | strftime: '%Y'))
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['strftime', ['%Y']]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['strftime', ['%Y']]], var.filters)
 
     var = create_variable(%( 'typo' | link_to: 'Typo', true ))
-    assert_equal 'typo', var.name
-    assert_equal [['link_to', ['Typo', true]]], var.filters
+    assert_equal('typo', var.name)
+    assert_equal([['link_to', ['Typo', true]]], var.filters)
 
     var = create_variable(%( 'typo' | link_to: 'Typo', false ))
-    assert_equal 'typo', var.name
-    assert_equal [['link_to', ['Typo', false]]], var.filters
+    assert_equal('typo', var.name)
+    assert_equal([['link_to', ['Typo', false]]], var.filters)
 
     var = create_variable(%( 'foo' | repeat: 3 ))
-    assert_equal 'foo', var.name
-    assert_equal [['repeat', [3]]], var.filters
+    assert_equal('foo', var.name)
+    assert_equal([['repeat', [3]]], var.filters)
 
     var = create_variable(%( 'foo' | repeat: 3, 3 ))
-    assert_equal 'foo', var.name
-    assert_equal [['repeat', [3, 3]]], var.filters
+    assert_equal('foo', var.name)
+    assert_equal([['repeat', [3, 3]]], var.filters)
 
     var = create_variable(%( 'foo' | repeat: 3, 3, 3 ))
-    assert_equal 'foo', var.name
-    assert_equal [['repeat', [3, 3, 3]]], var.filters
+    assert_equal('foo', var.name)
+    assert_equal([['repeat', [3, 3, 3]]], var.filters)
 
     var = create_variable(%( hello | strftime: '%Y, okay?'))
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['strftime', ['%Y, okay?']]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['strftime', ['%Y, okay?']]], var.filters)
 
     var = create_variable(%( hello | things: "%Y, okay?", 'the other one'))
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['things', ['%Y, okay?', 'the other one']]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['things', ['%Y, okay?', 'the other one']]], var.filters)
   end
 
   def test_filter_with_date_parameter
     var = create_variable(%( '2006-06-06' | date: "%m/%d/%Y"))
-    assert_equal '2006-06-06', var.name
-    assert_equal [['date', ['%m/%d/%Y']]], var.filters
+    assert_equal('2006-06-06', var.name)
+    assert_equal([['date', ['%m/%d/%Y']]], var.filters)
   end
 
   def test_filters_without_whitespace
     var = create_variable('hello | textileze | paragraph')
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze', []], ['paragraph', []]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable('hello|textileze|paragraph')
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['textileze', []], ['paragraph', []]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable("hello|replace:'foo','bar'|textileze")
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['replace', ['foo', 'bar']], ['textileze', []]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['replace', ['foo', 'bar']], ['textileze', []]], var.filters)
   end
 
   def test_symbol
     var = create_variable("http://disney.com/logo.gif | image: 'med' ", error_mode: :lax)
-    assert_equal VariableLookup.new('http://disney.com/logo.gif'), var.name
-    assert_equal [['image', ['med']]], var.filters
+    assert_equal(VariableLookup.new('http://disney.com/logo.gif'), var.name)
+    assert_equal([['image', ['med']]], var.filters)
   end
 
   def test_string_to_filter
     var = create_variable("'http://disney.com/logo.gif' | image: 'med' ")
-    assert_equal 'http://disney.com/logo.gif', var.name
-    assert_equal [['image', ['med']]], var.filters
+    assert_equal('http://disney.com/logo.gif', var.name)
+    assert_equal([['image', ['med']]], var.filters)
   end
 
   def test_string_single_quoted
     var = create_variable(%( "hello" ))
-    assert_equal 'hello', var.name
+    assert_equal('hello', var.name)
   end
 
   def test_string_double_quoted
     var = create_variable(%( 'hello' ))
-    assert_equal 'hello', var.name
+    assert_equal('hello', var.name)
   end
 
   def test_integer
     var = create_variable(%( 1000 ))
-    assert_equal 1000, var.name
+    assert_equal(1000, var.name)
   end
 
   def test_float
     var = create_variable(%( 1000.01 ))
-    assert_equal 1000.01, var.name
+    assert_equal(1000.01, var.name)
   end
 
   def test_dashes
-    assert_equal VariableLookup.new('foo-bar'), create_variable('foo-bar').name
-    assert_equal VariableLookup.new('foo-bar-2'), create_variable('foo-bar-2').name
+    assert_equal(VariableLookup.new('foo-bar'), create_variable('foo-bar').name)
+    assert_equal(VariableLookup.new('foo-bar-2'), create_variable('foo-bar-2').name)
 
     with_error_mode :strict do
       assert_raises(Liquid::SyntaxError) { create_variable('foo - bar') }
@@ -117,24 +117,24 @@ class VariableUnitTest < Minitest::Test
 
   def test_string_with_special_chars
     var = create_variable(%( 'hello! $!@.;"ddasd" ' ))
-    assert_equal 'hello! $!@.;"ddasd" ', var.name
+    assert_equal('hello! $!@.;"ddasd" ', var.name)
   end
 
   def test_string_dot
     var = create_variable(%( test.test ))
-    assert_equal VariableLookup.new('test.test'), var.name
+    assert_equal(VariableLookup.new('test.test'), var.name)
   end
 
   def test_filter_with_keyword_arguments
     var = create_variable(%( hello | things: greeting: "world", farewell: 'goodbye'))
-    assert_equal VariableLookup.new('hello'), var.name
-    assert_equal [['things', [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters
+    assert_equal(VariableLookup.new('hello'), var.name)
+    assert_equal([['things', [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters)
   end
 
   def test_lax_filter_argument_parsing
     var = create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ), error_mode: :lax)
-    assert_equal VariableLookup.new('number_of_comments'), var.name
-    assert_equal [['pluralize', ['comment', 'comments']]], var.filters
+    assert_equal(VariableLookup.new('number_of_comments'), var.name)
+    assert_equal([['pluralize', ['comment', 'comments']]], var.filters)
   end
 
   def test_strict_filter_argument_parsing
@@ -147,13 +147,13 @@ class VariableUnitTest < Minitest::Test
 
   def test_output_raw_source_of_variable
     var = create_variable(%( name_of_variable | upcase ))
-    assert_equal " name_of_variable | upcase ", var.raw
+    assert_equal(" name_of_variable | upcase ", var.raw)
   end
 
   def test_variable_lookup_interface
     lookup = VariableLookup.new('a.b.c')
-    assert_equal 'a', lookup.name
-    assert_equal ['b', 'c'], lookup.lookups
+    assert_equal('a', lookup.name)
+    assert_equal(['b', 'c'], lookup.lookups)
   end
 
   private