Temporarily use liquid-c branch for its corresponding change

[StaticRegisters] Add test coverage

.rubocop-https---shopify-github-io-ruby-style-guide-rubocop-yml

@@ -1,3 +1,5 @@
+# Recommended rubocop version: ~> 0.78.0
+
 AllCops:
   Exclude:
   - 'db/schema.rb'
@@ -20,7 +22,7 @@ Style/Alias:
   - prefer_alias
   - prefer_alias_method
 
-Layout/AlignHash:
+Layout/HashAlignment:
   EnforcedHashRocketStyle: key
   EnforcedColonStyle: key
   EnforcedLastArgumentHashStyle: ignore_implicit
@@ -30,7 +32,7 @@ Layout/AlignHash:
   - ignore_implicit
   - ignore_explicit
 
-Layout/AlignParameters:
+Layout/ParameterAlignment:
   EnforcedStyle: with_fixed_indentation
   SupportedStyles:
   - with_first_parameter
@@ -172,7 +174,7 @@ Naming/FileName:
   Regex:
   IgnoreExecutableScripts: true
 
-Layout/IndentFirstArgument:
+Layout/FirstArgumentIndentation:
   EnforcedStyle: consistent
   SupportedStyles:
   - consistent
@@ -225,7 +227,7 @@ Layout/IndentationConsistency:
 Layout/IndentationWidth:
   Width: 2
 
-Layout/IndentFirstArrayElement:
+Layout/FirstArrayElementIndentation:
   EnforcedStyle: consistent
   SupportedStyles:
   - special_inside_parentheses
@@ -233,10 +235,10 @@ Layout/IndentFirstArrayElement:
   - align_brackets
   IndentationWidth:
 
-Layout/IndentAssignment:
+Layout/AssignmentIndentation:
   IndentationWidth:
 
-Layout/IndentFirstHashElement:
+Layout/FirstHashElementIndentation:
   EnforcedStyle: consistent
   SupportedStyles:
   - special_inside_parentheses
@@ -340,9 +342,9 @@ Style/PercentQLiterals:
 Naming/PredicateName:
   NamePrefix:
   - is_
-  NamePrefixBlacklist:
+  ForbiddenPrefixes:
   - is_
-  NameWhitelist:
+  AllowedMethods:
   - is_a?
   Exclude:
   - 'spec/**/*'
@@ -467,7 +469,7 @@ Style/TernaryParentheses:
   - require_no_parentheses
   AllowSafeAssignment: true
 
-Layout/TrailingBlankLines:
+Layout/TrailingEmptyLines:
   EnforcedStyle: final_newline
   SupportedStyles:
   - final_newline
@@ -478,7 +480,7 @@ Style/TrivialAccessors:
   AllowPredicates: true
   AllowDSLWriters: false
   IgnoreClassMethods: false
-  Whitelist:
+  AllowedMethods:
   - to_ary
   - to_a
   - to_c
@@ -509,7 +511,7 @@ Style/WhileUntilModifier:
 Metrics/BlockNesting:
   Max: 3
 
-Metrics/LineLength:
+Layout/LineLength:
   Max: 120
   AllowHeredoc: true
   AllowURI: true
@@ -561,7 +563,7 @@ Lint/UnusedMethodArgument:
 Naming/AccessorMethodName:
   Enabled: true
 
-Layout/AlignArray:
+Layout/ArrayAlignment:
   Enabled: true
 
 Style/ArrayJoin:
@@ -819,13 +821,13 @@ Layout/TrailingWhitespace:
 Style/UnlessElse:
   Enabled: true
 
-Style/UnneededCapitalW:
+Style/RedundantCapitalW:
   Enabled: true
 
-Style/UnneededInterpolation:
+Style/RedundantInterpolation:
   Enabled: true
 
-Style/UnneededPercentQ:
+Style/RedundantPercentQ:
   Enabled: true
 
 Style/VariableInterpolation:
@@ -840,7 +842,7 @@ Style/WhileUntilDo:
 Style/ZeroLengthPredicate:
   Enabled: true
 
-Layout/IndentHeredoc:
+Layout/HeredocIndentation:
   EnforcedStyle: squiggly
 
 Lint/AmbiguousOperator:
@@ -864,7 +866,7 @@ Lint/DeprecatedClassMethods:
 Lint/DuplicateMethods:
   Enabled: true
 
-Lint/DuplicatedKey:
+Lint/DuplicateHashKey:
   Enabled: true
 
 Lint/EachWithObjectArgument:
@@ -891,8 +893,8 @@ Lint/FloatOutOfRange:
 Lint/FormatParameterMismatch:
   Enabled: true
 
-Lint/HandleExceptions:
-  Enabled: true
+Lint/SuppressedException:
+  AllowComments: true
 
 Lint/ImplicitStringConcatenation:
   Description: Checks for adjacent string literals on the same line, which could
@@ -947,7 +949,7 @@ Lint/ShadowedException:
 Lint/ShadowingOuterLocalVariable:
   Enabled: true
 
-Lint/StringConversionInInterpolation:
+Lint/RedundantStringCoercion:
   Enabled: true
 
 Lint/UnderscorePrefixedVariableName:
@@ -956,13 +958,13 @@ Lint/UnderscorePrefixedVariableName:
 Lint/UnifiedInteger:
   Enabled: true
 
-Lint/UnneededCopDisableDirective:
+Lint/RedundantCopDisableDirective:
   Enabled: true
 
-Lint/UnneededCopEnableDirective:
+Lint/RedundantCopEnableDirective:
   Enabled: true
 
-Lint/UnneededSplatExpansion:
+Lint/RedundantSplatExpansion:
   Enabled: true
 
 Lint/UnreachableCode:

.rubocop_todo.yml

@@ -18,7 +18,7 @@ Lint/InheritException:
 # Cop supports --auto-correct.
 # Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
-Metrics/LineLength:
+Layout/LineLength:
   Max: 294
 
 # Offense count: 44

.travis.yml

@@ -4,8 +4,8 @@ cache: bundler
 rvm:
   - 2.4
   - 2.5
-  - &latest_ruby 2.6
-  - 2.7
+  - 2.6
+  - &latest_ruby 2.7
   - ruby-head
 
 matrix:

Gemfile

@@ -18,10 +18,10 @@ group :benchmark, :test do
 end
 
 group :test do
-  gem 'rubocop', '~> 0.74.0', require: false
+  gem 'rubocop', '~> 0.78.0', require: false
   gem 'rubocop-performance', require: false
 
   platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'optimize-invoke-filter-refactor'
   end
 end

History.md

@@ -1,5 +1,11 @@
 # Liquid Change Log
 
+### Unreleased
+
+* Split Strainer class as a factory and a template (#1208) [Thierry Joyal]
+* Remove handling of a nil context in the Strainer class (#1218) [Thierry Joyal]
+* StaticRegisters#fetch to raise on missing key (#1250) [Thierry Joyal]
+
 ## 4.0.3 / 2019-03-12
 
 ### Fixed

Rakefile

@@ -11,7 +11,7 @@ desc('run test suite with default parser')
 Rake::TestTask.new(:base_test) do |t|
   t.libs << '.' << 'lib' << 'test'
   t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
-  t.verbose = false
+  t.verbose    = false
 end
 
 desc('run test suite with warn error mode')

example/server/liquid_servlet.rb

@@ -12,16 +12,16 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   private
 
   def handle(_type, req, res)
-    @request = req
+    @request  = req
     @response = res
 
     @request.path_info =~ /(\w+)\z/
-    @action = Regexp.last_match(1) || 'index'
+    @action  = Regexp.last_match(1) || 'index'
     @assigns = send(@action) if respond_to?(@action)
 
     @response['Content-Type'] = "text/html"
     @response.status = 200
-    @response.body = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
+    @response.body   = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
   end
 
   def read_template(filename = @action)

lib/liquid.rb

@@ -57,11 +57,14 @@ require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer'
+require 'liquid/strainer_factory'
+require 'liquid/strainer_template'
 require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
+require 'liquid/tag/disabler'
+require 'liquid/tag/disableable'
 require 'liquid/block'
 require 'liquid/block_body'
 require 'liquid/document'
@@ -80,8 +83,8 @@ require 'liquid/partial_cache'
 require 'liquid/usage'
 require 'liquid/register'
 require 'liquid/static_registers'
+require 'liquid/template_factory'
 
 # 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

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
+require 'English'
+
 module Liquid
   class BlockBody
-    LiquidTagToken = /\A\s*(\w+)\s*(.*?)\z/o
-    FullToken = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    LiquidTagToken      = /\A\s*(\w+)\s*(.*?)\z/o
+    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
     WhitespaceOrNothing = /\A\s*\z/
-    TAGSTART = "{%"
-    VARSTART = "{{"
+    TAGSTART            = "{%"
+    VARSTART            = "{{"
 
     attr_reader :nodelist
 
     def initialize
       @nodelist = []
-      @blank = true
+      @blank    = true
     end
 
     def parse(tokenizer, parse_context, &block)
@@ -35,7 +37,7 @@ module Liquid
             return yield token, token
           end
           tag_name = Regexp.last_match(1)
-          markup = Regexp.last_match(2)
+          markup   = Regexp.last_match(2)
           unless (tag = registered_tags[tag_name])
             # end parsing if we reach an unknown tag and let the caller decide
             # determine how to proceed
@@ -51,6 +53,21 @@ module Liquid
       yield nil, nil
     end
 
+    # @api private
+    def self.unknown_tag_in_liquid_tag(end_tag_name, end_tag_markup)
+      yield end_tag_name, end_tag_markup
+    ensure
+      Usage.increment("liquid_tag_contains_outer_tag") unless $ERROR_INFO.is_a?(SyntaxError)
+    end
+
+    private def parse_liquid_tag(markup, parse_context, &block)
+      liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
+      parse_for_liquid_tag(liquid_tag_tokenizer, parse_context) do |end_tag_name, end_tag_markup|
+        next unless end_tag_name
+        self.class.unknown_tag_in_liquid_tag(end_tag_name, end_tag_markup, &block)
+      end
+    end
+
     private def parse_for_document(tokenizer, parse_context, &block)
       while (token = tokenizer.shift)
         next if token.empty?
@@ -61,7 +78,7 @@ module Liquid
             raise_missing_tag_terminator(token, parse_context)
           end
           tag_name = Regexp.last_match(2)
-          markup = Regexp.last_match(4)
+          markup   = Regexp.last_match(4)
 
           if parse_context.line_number
             # newlines inside the tag should increase the line number,
@@ -70,8 +87,8 @@ module Liquid
           end
 
           if tag_name == 'liquid'
-            liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
-            next parse_for_liquid_tag(liquid_tag_tokenizer, parse_context, &block)
+            parse_liquid_tag(markup, parse_context, &block)
+            next
           end
 
           unless (tag = registered_tags[tag_name])
@@ -154,13 +171,7 @@ module Liquid
     private
 
     def render_node(context, output, node)
-      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
+      node.render_to_output_buffer(context, output)
     rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
       context.handle_error(e, node.line_number)
     rescue ::StandardError => e
@@ -168,11 +179,6 @@ 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?
@@ -180,8 +186,8 @@ module Liquid
     end
 
     def create_variable(token, parse_context)
-      token.scan(ContentOfVariable) do |content|
-        markup = content.first
+      if token =~ ContentOfVariable
+        markup = Regexp.last_match(1)
         return Variable.new(markup, parse_context)
       end
       raise_missing_variable_terminator(token, parse_context)

lib/liquid/condition.rb

@@ -35,10 +35,11 @@ module Liquid
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left = left
+      @left     = left
       @operator = operator
-      @right = right
-      @child_relation = nil
+      @right    = right
+
+      @child_relation  = nil
       @child_condition = nil
     end
 
@@ -62,12 +63,12 @@ module Liquid
     end
 
     def or(condition)
-      @child_relation = :or
+      @child_relation  = :or
       @child_condition = condition
     end
 
     def and(condition)
-      @child_relation = :and
+      @child_relation  = :and
       @child_condition = condition
     end
 
@@ -115,7 +116,7 @@ module Liquid
       # return this as the result.
       return context.evaluate(left) if op.nil?
 
-      left = context.evaluate(left)
+      left  = context.evaluate(left)
       right = context.evaluate(right)
 
       operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")

lib/liquid/context.rb

@@ -41,9 +41,10 @@ module Liquid
         self.exception_renderer = ->(_e) { raise }
       end
 
-      @interrupts = []
-      @filters = []
+      @interrupts    = []
+      @filters       = []
       @global_filter = nil
+      @disabled_tags = {}
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -52,7 +53,7 @@ module Liquid
     end
 
     def strainer
-      @strainer ||= Strainer.create(self, @filters)
+      @strainer ||= StrainerFactory.create(self, @filters)
     end
 
     # Adds filters to this context.
@@ -87,13 +88,18 @@ module Liquid
     def handle_error(e, line_number = nil)
       e = internal_error unless e.is_a?(Liquid::Error)
       e.template_name ||= template_name
-      e.line_number ||= line_number
+      e.line_number   ||= line_number
       errors.push(e)
       exception_renderer.call(e).to_s
     end
 
-    def invoke(method, *args)
-      strainer.invoke(method, *args).to_liquid
+    def invoke(method, input, *args)
+      strainer.invoke(method, input, *args).to_liquid
+    end
+
+    # @api private
+    def invoke_filter(method, input, args)
+      strainer.invoke_filter(method, input, args).to_liquid
     end
 
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
@@ -138,12 +144,13 @@ module Liquid
         static_environments: static_environments,
         registers: StaticRegisters.new(registers)
       ).tap do |subcontext|
-        subcontext.base_scope_depth = base_scope_depth + 1
+        subcontext.base_scope_depth   = base_scope_depth + 1
         subcontext.exception_renderer = exception_renderer
-        subcontext.filters = @filters
+        subcontext.filters  = @filters
         subcontext.strainer = nil
-        subcontext.errors = errors
+        subcontext.errors   = errors
         subcontext.warnings = warnings
+        subcontext.disabled_tags = @disabled_tags
       end
     end
 
@@ -188,7 +195,7 @@ module Liquid
         try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
       end
 
-      variable = variable.to_liquid
+      variable         = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
       variable
@@ -208,9 +215,24 @@ module Liquid
       end
     end
 
+    def with_disabled_tags(tag_names)
+      tag_names.each do |name|
+        @disabled_tags[name] = @disabled_tags.fetch(name, 0) + 1
+      end
+      yield
+    ensure
+      tag_names.each do |name|
+        @disabled_tags[name] -= 1
+      end
+    end
+
+    def tag_disabled?(tag_name)
+      @disabled_tags.fetch(tag_name, 0) > 0
+    end
+
     protected
 
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
 
     private
 

lib/liquid/errors.rb

@@ -40,19 +40,19 @@ module Liquid
     end
   end
 
-  ArgumentError = Class.new(Error)
-  ContextError = Class.new(Error)
-  FileSystemError = Class.new(Error)
-  StandardError = Class.new(Error)
-  SyntaxError = Class.new(Error)
-  StackLevelError = Class.new(Error)
-  TaintedError = Class.new(Error)
-  MemoryError = Class.new(Error)
-  ZeroDivisionError = Class.new(Error)
-  FloatDomainError = Class.new(Error)
-  UndefinedVariable = Class.new(Error)
+  ArgumentError       = Class.new(Error)
+  ContextError        = Class.new(Error)
+  FileSystemError     = Class.new(Error)
+  StandardError       = Class.new(Error)
+  SyntaxError         = Class.new(Error)
+  StackLevelError     = Class.new(Error)
+  MemoryError         = Class.new(Error)
+  ZeroDivisionError   = Class.new(Error)
+  FloatDomainError    = Class.new(Error)
+  UndefinedVariable   = Class.new(Error)
   UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter = Class.new(Error)
+  UndefinedFilter     = Class.new(Error)
   MethodOverrideError = Class.new(Error)
-  InternalError = Class.new(Error)
+  DisabledError       = Class.new(Error)
+  InternalError       = Class.new(Error)
 end

lib/liquid/file_system.rb

@@ -47,7 +47,7 @@ module Liquid
     attr_accessor :root
 
     def initialize(root, pattern = "_%s.liquid")
-      @root = root
+      @root    = root
       @pattern = pattern
     end
 

lib/liquid/forloop_drop.rb

@@ -3,10 +3,10 @@
 module Liquid
   class ForloopDrop < Drop
     def initialize(name, length, parentloop)
-      @name = name
-      @length = length
+      @name       = name
+      @length     = length
       @parentloop = parentloop
-      @index = 0
+      @index      = 0
     end
 
     attr_reader :name, :length, :parentloop

lib/liquid/lexer.rb

@@ -15,12 +15,12 @@ module Liquid
       '?' => :question,
       '-' => :dash,
     }.freeze
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
+    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
-    NUMBER_LITERAL = /-?\d+(\.\d+)?/
-    DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
+    DOTDOT                = /\.\./
+    COMPARISON_OPERATOR   = /==|!=|<>|<=?|>=?|contains(?=\s)/
     WHITESPACE_OR_NOTHING = /\s*/
 
     def initialize(input)
@@ -33,7 +33,7 @@ module Liquid
       until @ss.eos?
         @ss.skip(WHITESPACE_OR_NOTHING)
         break if @ss.eos?
-        tok = if (t = @ss.scan(COMPARISON_OPERATOR))
+        tok      = if (t = @ss.scan(COMPARISON_OPERATOR))
           [:comparison, t]
         elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
           [:string, t]
@@ -46,7 +46,7 @@ module Liquid
         elsif (t = @ss.scan(DOTDOT))
           [:dotdot, t]
         else
-          c = @ss.getch
+          c     = @ss.getch
           if (s = SPECIALS[c])
             [s, c]
           else

lib/liquid/parse_context.rb

@@ -7,9 +7,11 @@ module Liquid
 
     def initialize(options = {})
       @template_options = options ? options.dup : {}
-      @locale = @template_options[:locale] ||= I18n.new
+
+      @locale   = @template_options[:locale] ||= I18n.new
       @warnings = []
-      self.depth = 0
+
+      self.depth   = 0
       self.partial = false
     end
 
@@ -20,6 +22,7 @@ module Liquid
     def partial=(value)
       @partial = value
       @options = value ? partial_options : @template_options
+
       @error_mode = @options[:error_mode] || Template.error_mode
     end
 

lib/liquid/parse_tree_visitor.rb

@@ -11,7 +11,7 @@ module Liquid
     end
 
     def initialize(node, callbacks)
-      @node = node
+      @node      = node
       @callbacks = callbacks
     end
 

lib/liquid/parser.rb

@@ -3,9 +3,9 @@
 module Liquid
   class Parser
     def initialize(input)
-      l = Lexer.new(input)
+      l       = Lexer.new(input)
       @tokens = l.tokenize
-      @p = 0 # pointer to current location
+      @p      = 0 # pointer to current location
     end
 
     def jump(point)

lib/liquid/parser_switching.rb

@@ -8,10 +8,10 @@ module Liquid
       when :lax    then lax_parse(markup)
       when :warn
         begin
-          return strict_parse_with_error_context(markup)
+          strict_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
-          return lax_parse(markup)
+          lax_parse(markup)
         end
       end
     end
@@ -21,7 +21,7 @@ module Liquid
     def strict_parse_with_error_context(markup)
       strict_parse(markup)
     rescue SyntaxError => e
-      e.line_number = line_number
+      e.line_number    = line_number
       e.markup_context = markup_context(markup)
       raise e
     end

lib/liquid/partial_cache.rb

@@ -8,10 +8,14 @@ module Liquid
       return cached if cached
 
       file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
-      source = file_system.read_template_file(template_name)
+      source      = file_system.read_template_file(template_name)
+
       parse_context.partial = true
 
-      partial = Liquid::Template.parse(source, parse_context)
+      template_factory = (context.registers[:template_factory] ||= Liquid::TemplateFactory.new)
+      template = template_factory.for(template_name)
+
+      partial = template.parse(source, parse_context)
       cached_partials[template_name] = partial
     ensure
       parse_context.partial = false

lib/liquid/profiler.rb

@@ -46,7 +46,7 @@ module Liquid
     include Enumerable
 
     class Timing
-      attr_reader :code, :partial, :line_number, :children
+      attr_reader :code, :partial, :line_number, :children, :total_time, :self_time
 
       def initialize(node, partial)
         @code        = node.respond_to?(:raw) ? node.raw : node
@@ -64,7 +64,18 @@ module Liquid
       end
 
       def finish
-        @end_time = Time.now
+        @end_time   = Time.now
+        @total_time = @end_time - @start_time
+
+        if @children.empty?
+          @self_time = @total_time
+        else
+          total_children_time = 0
+          @children.each do |child|
+            total_children_time += child.total_time
+          end
+          @self_time = @total_time - total_children_time
+        end
       end
 
       def render_time
@@ -98,14 +109,14 @@ module Liquid
       Thread.current[:liquid_profiler]
     end
 
-    def initialize
-      @partial_stack = ["<root>"]
+    def initialize(partial_name = "<root>")
+      @partial_stack = [partial_name]
 
-      @root_timing = Timing.new("", current_partial)
+      @root_timing  = Timing.new("", current_partial)
       @timing_stack = [@root_timing]
 
       @render_start_at = Time.now
-      @render_end_at = @render_start_at
+      @render_end_at   = @render_start_at
     end
 
     def start

lib/liquid/profiler/hooks.rb

@@ -1,25 +1,21 @@
 # frozen_string_literal: true
 
 module Liquid
-  class BlockBody
-    def render_node_with_profiling(context, output, node)
+  module BlockBodyProfilingHook
+    def render_node(context, output, node)
       Profiler.profile_node_render(node) do
-        render_node_without_profiling(context, output, node)
+        super
       end
     end
-
-    alias_method :render_node_without_profiling, :render_node
-    alias_method :render_node, :render_node_with_profiling
   end
+  BlockBody.prepend(BlockBodyProfilingHook)
 
-  class Include < Tag
-    def render_to_output_buffer_with_profiling(context, output)
+  module IncludeProfilingHook
+    def render_to_output_buffer(context, output)
       Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_to_output_buffer_without_profiling(context, output)
+        super
       end
     end
-
-    alias_method :render_to_output_buffer_without_profiling, :render_to_output_buffer
-    alias_method :render_to_output_buffer, :render_to_output_buffer_with_profiling
   end
+  Include.prepend(IncludeProfilingHook)
 end

lib/liquid/range_lookup.rb

@@ -4,7 +4,7 @@ module Liquid
   class RangeLookup
     def self.parse(start_markup, end_markup)
       start_obj = Expression.parse(start_markup)
-      end_obj = Expression.parse(end_markup)
+      end_obj   = Expression.parse(end_markup)
       if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
         new(start_obj, end_obj)
       else
@@ -14,12 +14,12 @@ module Liquid
 
     def initialize(start_obj, end_obj)
       @start_obj = start_obj
-      @end_obj = end_obj
+      @end_obj   = end_obj
     end
 
     def evaluate(context)
       start_int = to_integer(context.evaluate(@start_obj))
-      end_int = to_integer(context.evaluate(@end_obj))
+      end_int   = to_integer(context.evaluate(@end_obj))
       start_int..end_int
     end
 

lib/liquid/registers/disabled_tags.rb

@@ -1,32 +0,0 @@
-# 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/resource_limits.rb

@@ -7,8 +7,8 @@ module Liquid
 
     def initialize(limits)
       @render_length_limit = limits[:render_length_limit]
-      @render_score_limit = limits[:render_score_limit]
-      @assign_score_limit = limits[:assign_score_limit]
+      @render_score_limit  = limits[:render_score_limit]
+      @assign_score_limit  = limits[:assign_score_limit]
       reset
     end
 

lib/liquid/standardfilters.rb

@@ -13,7 +13,7 @@ module Liquid
       "'" => ''',
     }.freeze
     HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
-    STRIP_HTML_BLOCKS = Regexp.union(
+    STRIP_HTML_BLOCKS       = Regexp.union(
       %r{<script.*?</script>}m,
       /<!--.*?-->/m,
       %r{<style.*?</style>}m
@@ -41,7 +41,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input.to_s).untaint unless input.nil?
+      CGI.escapeHTML(input.to_s) unless input.nil?
     end
     alias_method :h, :escape
 
@@ -77,19 +77,24 @@ module Liquid
     def truncate(input, length = 50, truncate_string = "...")
       return if input.nil?
       input_str = input.to_s
-      length = Utils.to_integer(length)
+      length    = Utils.to_integer(length)
+
       truncate_string_str = truncate_string.to_s
+
       l = length - truncate_string_str.length
       l = 0 if l < 0
+
       input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
     end
 
     def truncatewords(input, words = 15, truncate_string = "...")
       return if input.nil?
       wordlist = input.to_s.split
-      words = Utils.to_integer(words)
+      words    = Utils.to_integer(words)
+
       l = words - 1
       l = 0 if l < 0
+
       wordlist.length > l ? wordlist[0..l].join(" ").concat(truncate_string.to_s) : input
     end
 
@@ -115,7 +120,7 @@ module Liquid
     end
 
     def strip_html(input)
-      empty = ''
+      empty  = ''
       result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
       result.gsub!(STRIP_HTML_TAGS, empty)
       result
@@ -128,13 +133,13 @@ module Liquid
 
     # Join elements of the array with certain character between them
     def join(input, glue = ' ')
-      InputIterator.new(input).join(glue)
+      InputIterator.new(input, context).join(glue)
     end
 
     # Sort elements of the array
     # provide optional property with which to sort an array of hashes or drops
     def sort(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       return [] if ary.empty?
 
@@ -154,7 +159,7 @@ module Liquid
     # Sort elements of an array ignoring case if strings
     # provide optional property with which to sort an array of hashes or drops
     def sort_natural(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       return [] if ary.empty?
 
@@ -174,7 +179,7 @@ module Liquid
     # Filter the elements of an array to those with a certain property value.
     # By default the target is any truthy value.
     def where(input, property, target_value = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       if ary.empty?
         []
@@ -196,7 +201,7 @@ module Liquid
     # Remove duplicate elements from an array
     # provide optional property with which to determine uniqueness
     def uniq(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       if property.nil?
         ary.uniq
@@ -213,13 +218,13 @@ module Liquid
 
     # Reverse the elements of an array
     def reverse(input)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
       ary.reverse
     end
 
     # map/collect on a given property
     def map(input, property)
-      InputIterator.new(input).map do |e|
+      InputIterator.new(input, context).map do |e|
         e = e.call if e.is_a?(Proc)
 
         if property == "to_liquid"
@@ -236,7 +241,7 @@ module Liquid
     # Remove nils within an array
     # provide optional property with which to check for nil
     def compact(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       if property.nil?
         ary.compact
@@ -280,7 +285,7 @@ module Liquid
       unless array.respond_to?(:to_ary)
         raise ArgumentError, "concat filter requires an array argument"
       end
-      InputIterator.new(input).concat(array)
+      InputIterator.new(input, context).concat(array)
     end
 
     # prepend a string to another
@@ -421,17 +426,26 @@ module Liquid
       result.is_a?(BigDecimal) ? result.to_f : result
     end
 
-    def default(input, default_value = '')
-      if !input || input.respond_to?(:empty?) && input.empty?
-        Usage.increment("default_filter_received_false_value") if input == false # See https://github.com/Shopify/liquid/issues/1127
-        default_value
-      else
-        input
-      end
+    # Set a default value when the input is nil, false or empty
+    #
+    # Example:
+    #    {{ product.title | default: "No Title" }}
+    #
+    # Use `allow_false` when an input should only be tested against nil or empty and not false.
+    #
+    # Example:
+    #    {{ product.title | default: "No Title", allow_false: true }}
+    #
+    def default(input, default_value = '', options = {})
+      options = {} unless options.is_a?(Hash)
+      false_check = options['allow_false'] ? input.nil? : !input
+      false_check || (input.respond_to?(:empty?) && input.empty?) ? default_value : input
     end
 
     private
 
+    attr_reader :context
+
     def raise_property_error(property)
       raise Liquid::ArgumentError, "cannot select the property '#{property}'"
     end
@@ -460,8 +474,9 @@ module Liquid
     class InputIterator
       include Enumerable
 
-      def initialize(input)
-        @input = if input.is_a?(Array)
+      def initialize(input, context)
+        @context = context
+        @input   = if input.is_a?(Array)
           input.flatten
         elsif input.is_a?(Hash)
           [input]
@@ -499,6 +514,7 @@ module Liquid
 
       def each
         @input.each do |e|
+          e.context = @context if e.respond_to?(:context=)
           yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
         end
       end

lib/liquid/static_registers.rb

@@ -2,10 +2,10 @@
 
 module Liquid
   class StaticRegisters
-    attr_reader :static, :registers
+    attr_reader :static
 
     def initialize(registers = {})
-      @static = registers.is_a?(StaticRegisters) ? registers.static : registers
+      @static    = registers.is_a?(StaticRegisters) ? registers.static : registers
       @registers = {}
     end
 
@@ -25,8 +25,16 @@ module Liquid
       @registers.delete(key)
     end
 
-    def fetch(key, default = nil)
-      key?(key) ? self[key] : default
+    UNDEFINED = Object.new
+
+    def fetch(key, default = UNDEFINED, &block)
+      if @registers.key?(key)
+        @registers.fetch(key)
+      elsif default != UNDEFINED
+        @static.fetch(key, default, &block)
+      else
+        @static.fetch(key, &block)
+      end
     end
 
     def key?(key)

lib/liquid/strainer.rb

@@ -1,68 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module Liquid
-  # Strainer is the parent class for the filters system.
-  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
-  #
-  # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
-  # Context#add_filters or Template.register_filter
-  class Strainer #:nodoc:
-    @@global_strainer = Class.new(Strainer) do
-      @filter_methods = Set.new
-    end
-    @@strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(@@global_strainer) do
-        @filter_methods = @@global_strainer.filter_methods.dup
-        filters.each { |f| add_filter(f) }
-      end
-    end
-
-    def initialize(context)
-      @context = context
-    end
-
-    class << self
-      attr_reader :filter_methods
-    end
-
-    def self.add_filter(filter)
-      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-      unless include?(filter)
-        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
-        if invokable_non_public_methods.any?
-          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
-        else
-          send(:include, filter)
-          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-        end
-      end
-    end
-
-    def self.global_filter(filter)
-      @@strainer_class_cache.clear
-      @@global_strainer.add_filter(filter)
-    end
-
-    def self.invokable?(method)
-      @filter_methods.include?(method.to_s)
-    end
-
-    def self.create(context, filters = [])
-      @@strainer_class_cache[filters].new(context)
-    end
-
-    def invoke(method, *args)
-      if self.class.invokable?(method)
-        send(method, *args)
-      elsif @context&.strict_filters
-        raise Liquid::UndefinedFilter, "undefined filter #{method}"
-      else
-        args.first
-      end
-    rescue ::ArgumentError => e
-      raise Liquid::ArgumentError, e.message, e.backtrace
-    end
-  end
-end

lib/liquid/strainer_factory.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Liquid
+  # StrainerFactory is the factory for the filters system.
+  module StrainerFactory
+    extend self
+
+    def add_global_filter(filter)
+      strainer_class_cache.clear
+      global_filters << filter
+    end
+
+    def create(context, filters = [])
+      strainer_from_cache(filters).new(context)
+    end
+
+    private
+
+    def global_filters
+      @global_filters ||= []
+    end
+
+    def strainer_from_cache(filters)
+      strainer_class_cache[filters] ||= begin
+        klass = Class.new(StrainerTemplate)
+        global_filters.each { |f| klass.add_filter(f) }
+        filters.each { |f| klass.add_filter(f) }
+        klass
+      end
+    end
+
+    def strainer_class_cache
+      @strainer_class_cache ||= {}
+    end
+  end
+end

lib/liquid/strainer_template.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Liquid
+  # StrainerTemplate is the computed class for the filters system.
+  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
+  #
+  # The Strainer only allows method calls defined in filters given to it via StrainerFactory.add_global_filter,
+  # Context#add_filters or Template.register_filter
+  class StrainerTemplate
+    def initialize(context)
+      @context = context
+    end
+
+    class << self
+      def add_filter(filter)
+        return if include?(filter)
+
+        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
+        if invokable_non_public_methods.any?
+          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
+        end
+
+        include(filter)
+
+        filter_methods.merge(filter.public_instance_methods)
+      end
+
+      def invokable?(method)
+        filter_methods.include?(method.to_sym)
+      end
+
+      private
+
+      def filter_methods
+        @filter_methods ||= Set.new
+      end
+    end
+
+    def invoke(method, input, *args)
+      invoke_filter(method.to_sym, input, args)
+    end
+
+    # @api private
+    def invoke_filter(method, input, args)
+      if self.class.invokable?(method)
+        send(method, input, *args)
+      elsif @context.strict_filters
+        raise Liquid::UndefinedFilter, "undefined filter #{method}"
+      else
+        input
+      end
+    rescue ::ArgumentError => e
+      raise Liquid::ArgumentError, e.message, e.backtrace
+    end
+  end
+end

lib/liquid/tablerowloop_drop.rb

@@ -4,10 +4,10 @@ module Liquid
   class TablerowloopDrop < Drop
     def initialize(length, cols)
       @length = length
-      @row = 1
-      @col = 1
-      @cols = cols
-      @index = 0
+      @row    = 1
+      @col    = 1
+      @cols   = cols
+      @index  = 0
     end
 
     attr_reader :length, :col, :row

lib/liquid/tag.rb

@@ -13,22 +13,20 @@ module Liquid
         tag
       end
 
-      def disable_tags(*tags)
-        disabled_tags.push(*tags)
+      def disable_tags(*tag_names)
+        @disabled_tags ||= []
+        @disabled_tags.concat(tag_names)
+        prepend(Disabler)
       end
 
       private :new
-
-      def disabled_tags
-        @disabled_tags ||= []
-      end
     end
 
     def initialize(tag_name, markup, parse_context)
-      @tag_name   = tag_name
-      @markup     = markup
+      @tag_name      = tag_name
+      @markup        = markup
       @parse_context = parse_context
-      @line_number = parse_context.line_number
+      @line_number   = parse_context.line_number
     end
 
     def parse(_tokens)
@@ -46,14 +44,6 @@ 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.
@@ -65,9 +55,5 @@ module Liquid
     def blank?
       false
     end
-
-    def disabled_tags
-      self.class.disabled_tags
-    end
   end
 end

lib/liquid/tag/disableable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Tag
+    module Disableable
+      def render_to_output_buffer(context, output)
+        if context.tag_disabled?(tag_name)
+          output << disabled_error(context)
+          return
+        end
+        super
+      end
+
+      def disabled_error(context)
+        # raise then rescue the exception so that the Context#exception_renderer can re-raise it
+        raise DisabledError, "#{tag_name} #{parse_context[:locale].t('errors.disabled.tag')}"
+      rescue DisabledError => exc
+        context.handle_error(exc, line_number)
+      end
+    end
+  end
+end

lib/liquid/tag/disabler.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Tag
+    module Disabler
+      module ClassMethods
+        attr_reader :disabled_tags
+      end
+
+      def self.prepended(base)
+        base.extend(ClassMethods)
+      end
+
+      def render_to_output_buffer(context, output)
+        context.with_disabled_tags(self.class.disabled_tags) do
+          super
+        end
+      end
+    end
+  end
+end

lib/liquid/tags/assign.rb

@@ -12,19 +12,15 @@ module Liquid
   class Assign < Tag
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
-    def self.syntax_error_translation_key
-      "errors.syntax.assign"
-    end
-
     attr_reader :to, :from
 
     def initialize(tag_name, markup, options)
       super
       if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to   = Regexp.last_match(1)
         @from = Variable.new(Regexp.last_match(2), options)
       else
-        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
+        raise SyntaxError, options[:locale].t('errors.syntax.assign')
       end
     end
 

lib/liquid/tags/cycle.rb

@@ -24,10 +24,10 @@ module Liquid
       case markup
       when NamedSyntax
         @variables = variables_from_string(Regexp.last_match(2))
-        @name = Expression.parse(Regexp.last_match(1))
+        @name      = Expression.parse(Regexp.last_match(1))
       when SimpleSyntax
         @variables = variables_from_string(markup)
-        @name = @variables.to_s
+        @name      = @variables.to_s
       else
         raise SyntaxError, options[:locale].t("errors.syntax.cycle")
       end
@@ -36,7 +36,7 @@ module Liquid
     def render_to_output_buffer(context, output)
       context.registers[:cycle] ||= {}
 
-      key = context.evaluate(@name)
+      key       = context.evaluate(@name)
       iteration = context.registers[:cycle][key].to_i
 
       val = context.evaluate(@variables[iteration])
@@ -50,9 +50,9 @@ module Liquid
       output << val
 
       iteration += 1
-      iteration  = 0 if iteration >= @variables.size
-      context.registers[:cycle][key] = iteration
+      iteration = 0 if iteration >= @variables.size
 
+      context.registers[:cycle][key] = iteration
       output
     end
 

lib/liquid/tags/for.rb

@@ -88,10 +88,10 @@ module Liquid
 
     def lax_parse(markup)
       if markup =~ Syntax
-        @variable_name = Regexp.last_match(1)
-        collection_name = Regexp.last_match(2)
-        @reversed = !!Regexp.last_match(3)
-        @name = "#{@variable_name}-#{collection_name}"
+        @variable_name   = Regexp.last_match(1)
+        collection_name  = Regexp.last_match(2)
+        @reversed        = !!Regexp.last_match(3)
+        @name            = "#{@variable_name}-#{collection_name}"
         @collection_name = Expression.parse(collection_name)
         markup.scan(TagAttributes) do |key, value|
           set_attribute(key, value)
@@ -105,9 +105,11 @@ module Liquid
       p = Parser.new(markup)
       @variable_name = p.consume(:id)
       raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
-      collection_name = p.expression
-      @name = "#{@variable_name}-#{collection_name}"
+
+      collection_name  = p.expression
       @collection_name = Expression.parse(collection_name)
+
+      @name     = "#{@variable_name}-#{collection_name}"
       @reversed = p.id?('reversed')
 
       while p.look(:id) && p.look(:colon, 1)
@@ -156,7 +158,7 @@ module Liquid
 
     def render_segment(context, output, segment)
       for_stack = context.registers[:for_stack] ||= []
-      length = segment.length
+      length    = segment.length
 
       context.stack do
         loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])

lib/liquid/tags/if.rb

@@ -12,9 +12,9 @@ module Liquid
   #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
   #
   class If < Block
-    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
+    Syntax                  = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
     ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS = %w(and or).freeze
+    BOOLEAN_OPERATORS       = %w(and or).freeze
 
     attr_reader :blocks
 

lib/liquid/tags/include.rb

@@ -16,21 +16,25 @@ module Liquid
   #   {% include 'product' for products %}
   #
   class Include < Tag
-    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
+    prepend Tag::Disableable
+
+    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    Syntax = SYNTAX
 
     attr_reader :template_name_expr, :variable_name_expr, :attributes
 
     def initialize(tag_name, markup, options)
       super
 
-      if markup =~ Syntax
+      if markup =~ SYNTAX
 
         template_name = Regexp.last_match(1)
         variable_name = Regexp.last_match(3)
 
+        @alias_name         = Regexp.last_match(5)
         @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
         @template_name_expr = Expression.parse(template_name)
-        @attributes = {}
+        @attributes         = {}
 
         markup.scan(TagAttributes) do |key, value|
           @attributes[key] = Expression.parse(value)
@@ -54,7 +58,7 @@ module Liquid
         parse_context: parse_context
       )
 
-      context_variable_name = template_name.split('/').last
+      context_variable_name = @alias_name || template_name.split('/').last
 
       variable = if @variable_name_expr
         context.evaluate(@variable_name_expr)
@@ -63,10 +67,10 @@ module Liquid
       end
 
       old_template_name = context.template_name
-      old_partial = context.partial
+      old_partial       = context.partial
       begin
         context.template_name = template_name
-        context.partial = true
+        context.partial       = true
         context.stack do
           @attributes.each do |key, value|
             context[key] = context.evaluate(value)
@@ -84,7 +88,7 @@ module Liquid
         end
       ensure
         context.template_name = old_template_name
-        context.partial = old_partial
+        context.partial       = old_partial
       end
 
       output

lib/liquid/tags/render.rb

@@ -2,7 +2,8 @@
 
 module Liquid
   class Render < Tag
-    SYNTAX = /(#{QuotedString})#{QuotedFragment}*/o
+    FOR = 'for'
+    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
 
     disable_tags "include"
 
@@ -14,8 +15,13 @@ module Liquid
       raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
 
       template_name = Regexp.last_match(1)
+      with_or_for = Regexp.last_match(3)
+      variable_name = Regexp.last_match(4)
 
+      @alias_name = Regexp.last_match(6)
+      @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
       @template_name_expr = Expression.parse(template_name)
+      @for = (with_or_for == FOR)
 
       @attributes = {}
       markup.scan(TagAttributes) do |key, value|
@@ -38,13 +44,29 @@ module Liquid
         parse_context: parse_context
       )
 
-      inner_context = context.new_isolated_subcontext
-      inner_context.template_name = template_name
-      inner_context.partial = true
-      @attributes.each do |key, value|
-        inner_context[key] = context.evaluate(value)
+      context_variable_name = @alias_name || template_name.split('/').last
+
+      render_partial_func = ->(var, forloop) {
+        inner_context               = context.new_isolated_subcontext
+        inner_context.template_name = template_name
+        inner_context.partial       = true
+        inner_context['forloop']    = forloop if forloop
+
+        @attributes.each do |key, value|
+          inner_context[key] = context.evaluate(value)
+        end
+        inner_context[context_variable_name] = var unless var.nil?
+        partial.render_to_output_buffer(inner_context, output)
+        forloop&.send(:increment!)
+      }
+
+      variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
+      if @for && variable.respond_to?(:each) && variable.respond_to?(:count)
+        forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
+        variable.each { |var| render_partial_func.call(var, forloop) }
+      else
+        render_partial_func.call(variable, nil)
       end
-      partial.render_to_output_buffer(inner_context, output)
 
       output
     end

lib/liquid/tags/table_row.rb

@@ -9,9 +9,9 @@ module Liquid
     def initialize(tag_name, markup, options)
       super
       if markup =~ Syntax
-        @variable_name = Regexp.last_match(1)
+        @variable_name   = Regexp.last_match(1)
         @collection_name = Expression.parse(Regexp.last_match(2))
-        @attributes = {}
+        @attributes      = {}
         markup.scan(TagAttributes) do |key, value|
           @attributes[key] = Expression.parse(value)
         end
@@ -24,11 +24,10 @@ module Liquid
       (collection = context.evaluate(@collection_name)) || (return '')
 
       from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
-      to = @attributes.key?('limit') ? from + context.evaluate(@attributes['limit']).to_i : nil
+      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
-
-      length = collection.length
+      length     = collection.length
 
       cols = context.evaluate(@attributes['cols']).to_i
 

lib/liquid/template.rb

@@ -18,13 +18,11 @@ module Liquid
     attr_accessor :root
     attr_reader :resource_limits, :warnings
 
-    @@file_system = BlankFileSystem.new
-
     class TagRegistry
       include Enumerable
 
       def initialize
-        @tags = {}
+        @tags  = {}
         @cache = {}
       end
 
@@ -63,84 +61,57 @@ module Liquid
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
       # :warn is the default and will give deprecation warnings when invalid syntax is used.
       # :strict will enforce correct syntax.
-      attr_writer :error_mode
-
-      # Sets how strict the taint checker should be.
-      # :lax is the default, and ignores the taint flag completely
-      # :warn adds a warning, but does not interrupt the rendering
-      # :error raises an error when tainted output is used
-      attr_writer :taint_mode
+      attr_accessor :error_mode
+      Template.error_mode = :lax
 
       attr_accessor :default_exception_renderer
       Template.default_exception_renderer = lambda do |exception|
         exception
       end
 
-      def file_system
-        @@file_system
-      end
+      attr_accessor :file_system
+      Template.file_system = BlankFileSystem.new
 
-      def file_system=(obj)
-        @@file_system = obj
-      end
+      attr_accessor :tags
+      Template.tags = TagRegistry.new
+      private :tags=
 
       def register_tag(name, klass)
         tags[name.to_s] = klass
       end
 
-      def tags
-        @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
-
-      def taint_mode
-        @taint_mode ||= :lax
-      end
-
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
-        Strainer.global_filter(mod)
+        StrainerFactory.add_global_filter(mod)
       end
 
-      def default_resource_limits
-        @default_resource_limits ||= {}
-      end
+      attr_accessor :default_resource_limits
+      Template.default_resource_limits = {}
+      private :default_resource_limits=
 
       # creates a new <tt>Template</tt> object from liquid source code
       # To enable profiling, pass in <tt>profile: true</tt> as an option.
       # See Liquid::Profiler for more information
       def parse(source, options = {})
-        template = Template.new
-        template.parse(source, options)
+        new.parse(source, options)
       end
     end
 
     def initialize
-      @rethrow_errors = false
-      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
+      @rethrow_errors  = false
+      @resource_limits = ResourceLimits.new(Template.default_resource_limits)
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
-      @options = options
-      @profiling = options[:profile]
+      @options      = options
+      @profiling    = options[:profile]
       @line_numbers = options[:line_numbers] || @profiling
       parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
-      @root = Document.parse(tokenize(source), parse_context)
-      @warnings = parse_context.warnings
+      @root         = Document.parse(tokenize(source), parse_context)
+      @warnings     = parse_context.warnings
       self
     end
 
@@ -187,7 +158,7 @@ module Liquid
 
         c
       when Liquid::Drop
-        drop = args.shift
+        drop         = args.shift
         drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when Hash
         Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
@@ -204,7 +175,7 @@ module Liquid
       case args.last
       when Hash
         options = args.pop
-        output = options[:output] if options[:output]
+        output  = options[:output] if options[:output]
 
         options[:registers]&.each do |key, register|
           context_register[key] = register
@@ -215,10 +186,6 @@ module Liquid
         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
 
@@ -254,7 +221,7 @@ module Liquid
       if @profiling && !context.partial
         raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
 
-        @profiler = Profiler.new
+        @profiler = Profiler.new(context.template_name)
         @profiler.start
 
         begin
@@ -269,10 +236,10 @@ module Liquid
 
     def apply_options_to_context(context, options)
       context.add_filters(options[:filters]) if options[:filters]
-      context.global_filter = options[:global_filter] if options[:global_filter]
+      context.global_filter      = options[:global_filter] if options[:global_filter]
       context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-      context.strict_variables = options[:strict_variables] if options[:strict_variables]
-      context.strict_filters = options[:strict_filters] if options[:strict_filters]
+      context.strict_variables   = options[:strict_variables] if options[:strict_variables]
+      context.strict_filters     = options[:strict_filters] if options[:strict_filters]
     end
   end
 end

lib/liquid/template_factory.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Liquid
+  class TemplateFactory
+    def for(_template_name)
+      Liquid::Template.new
+    end
+  end
+end

lib/liquid/tokenizer.rb

@@ -5,10 +5,10 @@ module Liquid
     attr_reader :line_number, :for_liquid_tag
 
     def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
-      @source = source
-      @line_number = line_number || (line_numbers ? 1 : nil)
+      @source         = source
+      @line_number    = line_number || (line_numbers ? 1 : nil)
       @for_liquid_tag = for_liquid_tag
-      @tokens = tokenize
+      @tokens         = tokenize
     end
 
     def shift

lib/liquid/utils.rb

@@ -12,7 +12,7 @@ module Liquid
 
     def self.slice_collection_using_each(collection, from, to)
       segments = []
-      index = 0
+      index    = 0
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       if collection.is_a?(String)

lib/liquid/variable.rb

@@ -12,23 +12,23 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterMarkupRegex = /#{FilterSeparator}\s*(.*)/om
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    FilterArgsRegex = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
-    JustTagAttributes = /\A#{TagAttributes}\z/o
+    FilterMarkupRegex        = /#{FilterSeparator}\s*(.*)/om
+    FilterParser             = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterArgsRegex          = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
+    JustTagAttributes        = /\A#{TagAttributes}\z/o
     MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
 
-    attr_accessor :filters, :name, :line_number
+    attr_accessor :name, :line_number
     attr_reader :parse_context
     alias_method :options, :parse_context
 
     include ParserSwitching
 
     def initialize(markup, parse_context)
-      @markup  = markup
-      @name    = nil
+      @markup        = markup
+      @name          = nil
       @parse_context = parse_context
-      @line_number = parse_context.line_number
+      @line_number   = parse_context.line_number
 
       parse_with_selected_parser(markup)
     end
@@ -45,9 +45,9 @@ module Liquid
       @filters = []
       return unless markup =~ MarkupWithQuotedFragment
 
-      name_markup = Regexp.last_match(1)
+      name_markup   = Regexp.last_match(1)
       filter_markup = Regexp.last_match(2)
-      @name = Expression.parse(name_markup)
+      @name         = Expression.parse(name_markup)
       if filter_markup =~ FilterMarkupRegex
         filters = Regexp.last_match(1).scan(FilterParser)
         filters.each do |f|
@@ -81,14 +81,15 @@ module Liquid
     end
 
     def render(context)
-      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
-        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        context.invoke(filter_name, output, *filter_args)
+      result = context.evaluate(@name)
+      @filters.each do |filter_name, constant_args, filter_args, filter_kwargs|
+        unless constant_args
+          filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
+        end
+        result = context.invoke_filter(filter_name, result, filter_args)
       end
 
-      obj = context.apply_global_filter(obj)
-      taint_check(context, obj)
-      obj
+      context.apply_global_filter(result)
     end
 
     def render_to_output_buffer(context, output)
@@ -112,21 +113,49 @@ module Liquid
       []
     end
 
+    def filters
+      @filters.map do |filter_name, constant_args, *filter_args_and_kwargs|
+        filter_name = filter_name.to_s
+        if constant_args
+          filter_args = filter_args_and_kwargs.first
+          if filter_args.last.is_a?(Hash)
+            filter_args = filter_args.dup
+            [filter_name, filter_args, filter_args.pop]
+          else
+            [filter_name, *filter_args_and_kwargs]
+          end
+        else
+          [filter_name, *filter_args_and_kwargs]
+        end
+      end
+    end
+
     private
 
     def parse_filter_expressions(filter_name, unparsed_args)
+      constant_args = true
       filter_args = []
       keyword_args = nil
       unparsed_args.each do |a|
         if (matches = a.match(JustTagAttributes))
           keyword_args ||= {}
-          keyword_args[matches[1]] = Expression.parse(matches[2])
+          expression = Expression.parse(matches[2])
+          constant_args &&= !expression.is_a?(VariableLookup)
+          keyword_args[matches[1]] = expression
         else
-          filter_args << Expression.parse(a)
+          expression = Expression.parse(a)
+          constant_args &&= !expression.is_a?(VariableLookup)
+          filter_args << expression
+        end
+      end
+      result = [filter_name.to_sym, constant_args, filter_args]
+      if keyword_args
+        if constant_args
+          filter_args << keyword_args
+        else
+          result << keyword_args
         end
       end
-      result = [filter_name, filter_args]
-      result << keyword_args if keyword_args
       result
     end
 
@@ -142,25 +171,6 @@ module Liquid
       parsed_args
     end
 
-    def taint_check(context, obj)
-      return unless obj.tainted?
-      return if Template.taint_mode == :lax
-
-      @markup =~ QuotedFragment
-      name = Regexp.last_match(0)
-
-      error = TaintedError.new("variable '#{name}' is tainted and was not escaped")
-      error.line_number = line_number
-      error.template_name = context.template_name
-
-      case Template.taint_mode
-      when :warn
-        context.warnings << error
-      when :error
-        raise error
-      end
-    end
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [@node.name] + @node.filters.flatten

lib/liquid/variable_lookup.rb

@@ -3,7 +3,7 @@
 module Liquid
   class VariableLookup
     SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size', 'first', 'last'].freeze
+    COMMAND_METHODS  = ['size', 'first', 'last'].freeze
 
     attr_reader :name, :lookups
 
@@ -20,7 +20,7 @@ module Liquid
       end
       @name = name
 
-      @lookups = lookups
+      @lookups       = lookups
       @command_flags = 0
 
       @lookups.each_index do |i|
@@ -34,7 +34,7 @@ module Liquid
     end
 
     def evaluate(context)
-      name = context.evaluate(@name)
+      name   = context.evaluate(@name)
       object = context.find_variable(name)
 
       @lookups.each_index do |i|
@@ -47,7 +47,7 @@ module Liquid
              (object.respond_to?(:fetch) && key.is_a?(Integer)))
 
           # if its a proc we will replace the entry with the proc
-          res = context.lookup_and_evaluate(object, key)
+          res    = context.lookup_and_evaluate(object, key)
           object = res.to_liquid
 
           # Some special cases. If the part wasn't in square brackets and

liquid.gemspec

@@ -27,6 +27,6 @@ Gem::Specification.new do |s|
 
   s.require_path = "lib"
 
-  s.add_development_dependency('rake', '~> 11.3')
+  s.add_development_dependency('rake', '~> 13.0')
   s.add_development_dependency('minitest')
 end

performance/benchmark.rb

@@ -7,7 +7,7 @@ Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
 Benchmark.ips do |x|
-  x.time = 10
+  x.time   = 10
   x.warmup = 5
 
   puts

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/comment_form.rb

@@ -8,7 +8,7 @@ class CommentForm < Liquid::Block
 
     if markup =~ Syntax
       @variable_name = Regexp.last_match(1)
-      @attributes = {}
+      @attributes    = {}
     else
       raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]"
     end

performance/shopify/paginate.rb

@@ -8,7 +8,7 @@ class Paginate < Liquid::Block
 
     if markup =~ Syntax
       @collection_name = Regexp.last_match(1)
-      @page_size = if Regexp.last_match(2)
+      @page_size       = if Regexp.last_match(2)
         Regexp.last_match(3).to_i
       else
         20

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
@@ -60,7 +60,7 @@ module ShopFilter
 
     case style
     when 'original'
-      return '/files/shops/random_number/' + url
+      '/files/shops/random_number/' + url
     when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
       "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
     else

performance/theme_runner.rb

@@ -58,9 +58,9 @@ class ThemeRunner
   # `render` is called to benchmark just the render portion of liquid
   def render
     @compiled_tests.each do |test|
-      tmpl = test[:tmpl]
+      tmpl    = test[:tmpl]
       assigns = test[:assigns]
-      layout = test[:layout]
+      layout  = test[:layout]
 
       if layout
         assigns['content_for_layout'] = tmpl.render!(assigns)
@@ -74,7 +74,7 @@ class ThemeRunner
   private
 
   def compile_and_render(template, layout, assigns, page_template, template_file)
-    compiled_test = compile_test(template, layout, assigns, page_template, template_file)
+    compiled_test                 = compile_test(template, layout, assigns, page_template, template_file)
     assigns['content_for_layout'] = compiled_test[:tmpl].render!(assigns)
     compiled_test[:layout].render!(assigns) if layout
   end
@@ -88,7 +88,7 @@ class ThemeRunner
   end
 
   def compile_test(template, layout, assigns, page_template, template_file)
-    tmpl = init_template(page_template, template_file)
+    tmpl            = init_template(page_template, template_file)
     parsed_template = tmpl.parse(template).dup
 
     if layout
@@ -113,9 +113,9 @@ class ThemeRunner
 
   # set up a new Liquid::Template object for use in `compile_and_render` and `compile_test`
   def init_template(page_template, template_file)
-    tmpl = Liquid::Template.new
-    tmpl.assigns['page_title'] = 'Page title'
-    tmpl.assigns['template'] = page_template
+    tmpl                         = Liquid::Template.new
+    tmpl.assigns['page_title']   = 'Page title'
+    tmpl.assigns['template']     = page_template
     tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
     tmpl
   end

test/integration/assign_test.rb

@@ -10,9 +10,9 @@ class AssignTest < Minitest::Test
     {% assign this-thing = 'Print this-thing' %}
     {{ this-thing }}
     END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    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

@@ -14,9 +14,9 @@ class CaptureTest < Minitest::Test
     {% capture this-thing %}Print this-thing{% endcapture %}
     {{ this-thing }}
     END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("Print this-thing", rendered.strip)
   end
 
   def test_capture_to_variable_from_outer_scope_if_existing
@@ -30,9 +30,9 @@ class CaptureTest < Minitest::Test
     {% endif %}
     {{var}}
     END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "test-string", rendered.gsub(/\s/, '')
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    assert_equal("test-string", rendered.gsub(/\s/, ''))
   end
 
   def test_assigning_from_capture
@@ -45,8 +45,8 @@ class CaptureTest < Minitest::Test
     {% endfor %}
     {{ first }}-{{ second }}
     END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "3-3", rendered.gsub(/\s/, '')
+    template        = Template.parse(template_source)
+    rendered        = template.render!
+    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

@@ -49,10 +49,6 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
-  def user_input
-    (+"foo").taint
-  end
-
   protected
 
   def callmenot
@@ -111,82 +107,61 @@ class DropsTest < Minitest::Test
 
   def test_product_drop
     tpl = Liquid::Template.parse('  ')
-    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
-  end
-
-  def test_rendering_raises_on_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      assert_raises TaintedError do
-        tpl.render!('product' => ProductDrop.new)
-      end
-    end
-  end
-
-  def test_rendering_warns_on_tainted_attr
-    with_taint_mode(:warn) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      context = Context.new('product' => ProductDrop.new)
-      tpl.render!(context)
-      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
-      assert_equal "variable 'product.user_input' is tainted and was not escaped", context.warnings.first.to_s(false)
-    end
-  end
-
-  def test_rendering_doesnt_raise_on_escaped_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
-      tpl.render!('product' => ProductDrop.new)
-    end
+    assert_equal('  ', tpl.render!('product' => ProductDrop.new))
   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_context_drop_array_with_map
+    output = Liquid::Template.parse(' {{ contexts | map: "bar" }} ').render!('contexts' => [ContextDrop.new, ContextDrop.new], 'bar' => "carrot")
+    assert_equal(' carrotcarrot ', 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 +172,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 +225,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 +236,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 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,26 +219,26 @@ 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
 
   def test_exception_renderer_exposing_non_liquid_error
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
+    template   = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
     exceptions = []
-    handler = ->(e) {
+    handler    = ->(e) {
       exceptions << e
       e.cause
     }
 
     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
@@ -252,12 +252,13 @@ class ErrorHandlingTest < Minitest::Test
 
     begin
       Liquid::Template.file_system = TestFileSystem.new
+
       template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
-      page = template.render('errors' => ErrorDrop.new)
+      page     = template.render('errors' => ErrorDrop.new)
     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,103 +55,103 @@ 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
-    @context['value'] = 3
+    @context['value']   = 3
     @context['numbers'] = [2, 1, 4, 3]
-    @context['words'] = ['expected', 'as', 'alphabetic']
-    @context['arrays'] = ['flower', 'are']
+    @context['words']   = ['expected', 'as', 'alphabetic']
+    @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
-    @context['words'] = ['case', 'Assert', 'Insensitive']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
+    @context['words']   = ['case', 'Assert', 'Insensitive']
+    @context['hashes']  = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
     @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
-    @context['words'] = ['a', nil, 'b', nil, 'c']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
+    @context['words']   = ['a', nil, 'b', nil, 'c']
+    @context['hashes']  = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
     @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
     @context['surname'] = 'john'
-    @context['input'] = 'hello %{first_name}, %{last_name}'
+    @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
+    output              = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
+    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 }} )
+    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 }} )
+    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 : ':-(' }} !
+    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 }} )
+    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 : ':-('}} !
+    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'}} )
+    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}} )
+    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 }} )
+    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' }} )
+    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/parse_tree_visitor_test.rb

@@ -238,7 +238,7 @@ class ParseTreeVisitorTest < Minitest::Test
   def traversal(template)
     ParseTreeVisitor
       .for(Template.parse(template).root)
-      .add_callback_for(VariableLookup, &:name)
+      .add_callback_for(VariableLookup) { |node| node.name } # rubocop:disable Style/SymbolProc
   end
 
   def visit(template)

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,15 +64,15 @@ 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
     with_error_mode(:lax) do
       assigns = { 'b' => 'bar', 'c' => 'baz' }
-      markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+      markup  = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
       assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
     end
   end

test/integration/registers/disabled_tags_test.rb

@@ -1,27 +0,0 @@
-# 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,38 @@ 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
+
+  def test_profiling_supports_self_time
+    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
+    t.render!("collection" => ["one", "two"])
+    leaf = t.profiler[0].children[0]
+
+    assert_operator(leaf.self_time, :>, 0)
+  end
+
+  def test_profiling_supports_total_time
+    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
+    t.render!
+
+    assert_operator(t.profiler[0].total_time, :>, 0)
   end
 end

test/integration/security_test.rb

@@ -16,31 +16,31 @@ class SecurityTest < Minitest::Test
   end
 
   def test_no_instance_eval
-    text = %( {{ '1+1' | 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_existing_instance_eval
-    text = %( {{ '1+1' | __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 }} )
+    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 }} )
+    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
@@ -48,33 +48,34 @@ class SecurityTest < Minitest::Test
 
     test = %( {{ "some_string" | a_bad_filter }} )
 
-    template = Template.parse(test)
-    assert_equal [], (Symbol.all_symbols - current_symbols)
+    Template.parse(test).render!
 
-    template.render!
-    assert_equal [], (Symbol.all_symbols - current_symbols)
+    GC.start
+    GC.start
+
+    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!
+    code  = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
+    assert_equal("rendered", Template.parse(code).render!)
   end
 
   def test_more_than_max_depth_nested_blocks_raises_exception
     depth = Liquid::Block::MAX_DEPTH + 1
-    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
+    code  = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
     assert_raises(Liquid::StackLevelError) do
       Template.parse(code).render!
     end

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,113 +98,116 @@ 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
-    input = [
+    input       = [
       { "price" => 4, "handle" => "alpha" },
       { "handle" => "beta" },
       { "price" => 1, "handle" => "gamma" },
@@ -218,21 +221,21 @@ 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
-    input = [
+    input       = [
       { "price" => "4", "handle" => "alpha" },
       { "handle" => "beta" },
       { "price" => "1", "handle" => "gamma" },
@@ -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
+    hash     = { "foo" => { "bar" => 42 } }
+    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 }
+    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,23 @@ 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"))
+    assert_template_result('bar', "{{ false | default: 'bar' }}")
+  end
+
+  def test_default_handle_false
+    assert_equal("foo", @filters.default("foo", "bar", "allow_false" => true))
+    assert_equal("bar", @filters.default(nil, "bar", "allow_false" => true))
+    assert_equal("bar", @filters.default("", "bar", "allow_false" => true))
+    assert_equal(false, @filters.default(false, "bar", "allow_false" => true))
+    assert_equal("bar", @filters.default([], "bar", "allow_false" => true))
+    assert_equal("bar", @filters.default({}, "bar", "allow_false" => true))
+    assert_template_result('false', "{{ false | default: 'bar', allow_false: true }}")
   end
 
   def test_cannot_access_private_methods
@@ -706,8 +720,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 +737,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 +758,57 @@ 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_all_filters_never_raise_non_liquid_exception
+    test_drop = TestDrop.new
+    test_drop.context = Context.new
+    test_enum = TestEnumerable.new
+    test_enum.context = Context.new
+    test_types = [
+      "foo",
+      123,
+      0,
+      0.0,
+      -1234.003030303,
+      -99999999,
+      1234.38383000383830003838300,
+      nil,
+      true,
+      false,
+      TestThing.new,
+      test_drop,
+      test_enum,
+      ["foo", "bar"],
+      { "foo" => "bar" },
+      { foo: "bar" },
+      [{ "foo" => "bar" }, { "foo" => 123 }, { "foo" => nil }, { "foo" => true }, { "foo" => ["foo", "bar"] }],
+      { 1 => "bar" },
+      ["foo", 123, nil, true, false, Drop, ["foo"], { foo: "bar" }],
+    ]
+    test_types.each do |first|
+      test_types.each do |other|
+        (@filters.methods - Object.methods).each do |method|
+          arg_count = @filters.method(method).arity
+          arg_count *= -1 if arg_count < 0
+          inputs = [first]
+          inputs << ([other] * (arg_count - 1)) if arg_count > 1
+          begin
+            @filters.send(method, *inputs)
+          rescue Liquid::ArgumentError, Liquid::ZeroDivisionError
+            nil
+          end
+        end
+      end
+    end
   end
 
   def test_where_no_target_value
@@ -762,13 +819,13 @@ 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
 
   def with_timezone(tz)
-    old_tz = ENV['TZ']
+    old_tz    = ENV['TZ']
     ENV['TZ'] = tz
     yield
   ensure

test/integration/tag/disableable_test.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TagDisableableTest < Minitest::Test
+  include Liquid
+
+  class DisableRaw < Block
+    disable_tags "raw"
+  end
+
+  class DisableRawEcho < Block
+    disable_tags "raw", "echo"
+  end
+
+  class DisableableRaw < Liquid::Raw
+    prepend Liquid::Tag::Disableable
+  end
+
+  class DisableableEcho < Liquid::Echo
+    prepend Liquid::Tag::Disableable
+  end
+
+  def test_disables_raw
+    with_disableable_tags do
+      with_custom_tag('disable', DisableRaw) do
+        output = Template.parse('{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}').render
+        assert_equal('Liquid error: raw usage is not allowed in this contextfoo', output)
+      end
+    end
+  end
+
+  def test_disables_echo_and_raw
+    with_disableable_tags do
+      with_custom_tag('disable', DisableRawEcho) do
+        output = Template.parse('{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}').render
+        assert_equal('Liquid error: raw usage is not allowed in this contextLiquid error: echo usage is not allowed in this context', output)
+      end
+    end
+  end
+
+  private
+
+  def with_disableable_tags
+    with_custom_tag('raw', DisableableRaw) do
+      with_custom_tag('echo', DisableableEcho) do
+        yield
+      end
+    end
+  end
+end

test/integration/tags/break_tag_test.rb

@@ -8,8 +8,8 @@ class BreakTagTest < Minitest::Test
   # tests that no weird errors are raised if break is called outside of a
   # block
   def test_break_with_no_block
-    assigns = { 'i' => 1 }
-    markup = '{% break %}'
+    assigns  = { 'i' => 1 }
+    markup   = '{% break %}'
     expected = ''
 
     assert_template_result(expected, markup, assigns)

test/integration/tags/continue_tag_test.rb

@@ -8,8 +8,8 @@ class ContinueTagTest < Minitest::Test
   # tests that no weird errors are raised if continue is called outside of a
   # block
   def test_continue_with_no_block
-    assigns = {}
-    markup = '{% continue %}'
+    assigns  = {}
+    markup   = '{% continue %}'
     expected = ''
 
     assert_template_result(expected, markup, assigns)

test/integration/tags/for_tag_test.rb

@@ -106,7 +106,7 @@ HERE
   end
 
   def test_limiting_with_invalid_limit
-    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
+    assigns  = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
     template = <<-MKUP
       {% for i in array limit: true offset: 1 %}
         {{ i }}
@@ -120,7 +120,7 @@ HERE
   end
 
   def test_limiting_with_invalid_offset
-    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
+    assigns  = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
     template = <<-MKUP
       {% for i in array limit: 1 offset: true %}
         {{ i }}
@@ -134,8 +134,8 @@ HERE
   end
 
   def test_dynamic_variable_limiting
-    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
-    assigns['limit'] = 2
+    assigns           = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
+    assigns['limit']  = 2
     assigns['offset'] = 2
 
     assert_template_result('34', '{%for i in array limit: limit offset: offset %}{{ i }}{%endfor%}', assigns)
@@ -152,8 +152,8 @@ HERE
   end
 
   def test_pause_resume
-    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
-    markup = <<-MKUP
+    assigns  = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup   = <<-MKUP
       {%for i in array.items limit: 3 %}{{i}}{%endfor%}
       next
       {%for i in array.items offset:continue limit: 3 %}{{i}}{%endfor%}
@@ -171,8 +171,8 @@ HERE
   end
 
   def test_pause_resume_limit
-    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
-    markup = <<-MKUP
+    assigns  = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup   = <<-MKUP
       {%for i in array.items limit:3 %}{{i}}{%endfor%}
       next
       {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
@@ -190,8 +190,8 @@ HERE
   end
 
   def test_pause_resume_big_limit
-    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
-    markup = <<-MKUP
+    assigns  = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup   = <<-MKUP
       {%for i in array.items limit:3 %}{{i}}{%endfor%}
       next
       {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
@@ -209,8 +209,8 @@ HERE
   end
 
   def test_pause_resume_big_offset
-    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
-    markup = '{%for i in array.items limit:3 %}{{i}}{%endfor%}
+    assigns  = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup   = '{%for i in array.items limit:3 %}{{i}}{%endfor%}
       next
       {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
       next
@@ -226,26 +226,26 @@ HERE
   def test_for_with_break
     assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] } }
 
-    markup = '{% for i in array.items %}{% break %}{% endfor %}'
+    markup   = '{% for i in array.items %}{% break %}{% endfor %}'
     expected = ""
     assert_template_result(expected, markup, assigns)
 
-    markup = '{% for i in array.items %}{{ i }}{% break %}{% endfor %}'
+    markup   = '{% for i in array.items %}{{ i }}{% break %}{% endfor %}'
     expected = "1"
     assert_template_result(expected, markup, assigns)
 
-    markup = '{% for i in array.items %}{% break %}{{ i }}{% endfor %}'
+    markup   = '{% for i in array.items %}{% break %}{{ i }}{% endfor %}'
     expected = ""
     assert_template_result(expected, markup, assigns)
 
-    markup = '{% for i in array.items %}{{ i }}{% if i > 3 %}{% break %}{% endif %}{% endfor %}'
+    markup   = '{% for i in array.items %}{{ i }}{% if i > 3 %}{% break %}{% endif %}{% endfor %}'
     expected = "1234"
     assert_template_result(expected, markup, assigns)
 
     # tests to ensure it only breaks out of the local for loop
     # and not all of them.
-    assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
-    markup = '{% for item in array %}' \
+    assigns  = { 'array' => [[1, 2], [3, 4], [5, 6]] }
+    markup   = '{% for item in array %}' \
                '{% for i in item %}' \
                  '{% if i == 1 %}' \
                    '{% break %}' \
@@ -257,8 +257,8 @@ HERE
     assert_template_result(expected, markup, assigns)
 
     # test break does nothing when unreached
-    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
-    markup = '{% for i in array.items %}{% if i == 9999 %}{% break %}{% endif %}{{ i }}{% endfor %}'
+    assigns  = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
+    markup   = '{% for i in array.items %}{% if i == 9999 %}{% break %}{% endif %}{{ i }}{% endfor %}'
     expected = '12345'
     assert_template_result(expected, markup, assigns)
   end
@@ -266,29 +266,29 @@ HERE
   def test_for_with_continue
     assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
 
-    markup = '{% for i in array.items %}{% continue %}{% endfor %}'
+    markup   = '{% for i in array.items %}{% continue %}{% endfor %}'
     expected = ""
     assert_template_result(expected, markup, assigns)
 
-    markup = '{% for i in array.items %}{{ i }}{% continue %}{% endfor %}'
+    markup   = '{% for i in array.items %}{{ i }}{% continue %}{% endfor %}'
     expected = "12345"
     assert_template_result(expected, markup, assigns)
 
-    markup = '{% for i in array.items %}{% continue %}{{ i }}{% endfor %}'
+    markup   = '{% for i in array.items %}{% continue %}{{ i }}{% endfor %}'
     expected = ""
     assert_template_result(expected, markup, assigns)
 
-    markup = '{% for i in array.items %}{% if i > 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
+    markup   = '{% for i in array.items %}{% if i > 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
     expected = "123"
     assert_template_result(expected, markup, assigns)
 
-    markup = '{% for i in array.items %}{% if i == 3 %}{% continue %}{% else %}{{ i }}{% endif %}{% endfor %}'
+    markup   = '{% for i in array.items %}{% if i == 3 %}{% continue %}{% else %}{{ i }}{% endif %}{% endfor %}'
     expected = "1245"
     assert_template_result(expected, markup, assigns)
 
     # tests to ensure it only continues the local for loop and not all of them.
-    assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
-    markup = '{% for item in array %}' \
+    assigns  = { 'array' => [[1, 2], [3, 4], [5, 6]] }
+    markup   = '{% for item in array %}' \
                '{% for i in item %}' \
                  '{% if i == 1 %}' \
                    '{% continue %}' \
@@ -300,8 +300,8 @@ HERE
     assert_template_result(expected, markup, assigns)
 
     # test continue does nothing when unreached
-    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
-    markup = '{% for i in array.items %}{% if i == 9999 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
+    assigns  = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
+    markup   = '{% for i in array.items %}{% if i == 9999 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
     expected = '12345'
     assert_template_result(expected, markup, assigns)
   end
@@ -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
@@ -389,41 +389,41 @@ HERE
   end
 
   def test_iterate_with_each_when_no_limit_applied
-    loader = LoaderDrop.new([1, 2, 3, 4, 5])
-    assigns = { 'items' => loader }
+    loader   = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns  = { 'items' => loader }
     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
-    loader = LoaderDrop.new([1, 2, 3, 4, 5])
-    assigns = { 'items' => loader }
+    loader   = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns  = { 'items' => loader }
     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
-    loader = LoaderDrop.new([1, 2, 3, 4, 5])
-    assigns = { 'items' => loader }
+    loader   = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns  = { 'items' => loader }
     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
-    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    loader         = LoaderDrop.new([1, 2, 3, 4, 5])
     loader_assigns = { 'items' => loader }
-    array_assigns = { 'items' => [1, 2, 3, 4, 5] }
-    expected = '34'
-    template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
+    array_assigns  = { 'items' => [1, 2, 3, 4, 5] }
+    expected       = '34'
+    template       = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
     assert_template_result(expected, template, loader_assigns)
     assert_template_result(expected, template, array_assigns)
   end
@@ -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/if_else_tag_test.rb

@@ -45,7 +45,7 @@ class IfElseTagTest < Minitest::Test
 
   def test_comparison_of_strings_containing_and_or_or
     awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
-    assigns = { 'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true }
+    assigns      = { 'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true }
     assert_template_result(' YES ', "{% if #{awful_markup} %} YES {% endif %}", assigns)
   end
 

test/integration/tags/include_tag_test.rb

@@ -8,6 +8,9 @@ class TestFileSystem
     when "product"
       "Product: {{ product.title }} "
 
+    when "product_alias"
+      "Product: {{ product.title }} "
+
     when "locale_variables"
       "Locale: {{echo1}} {{echo2}}"
 
@@ -51,7 +54,7 @@ class CountingFileSystem
   attr_reader :count
   def read_template_file(_template_path)
     @count ||= 0
-    @count += 1
+    @count  += 1
     'from CountingFileSystem'
   end
 end
@@ -82,56 +85,66 @@ 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_alias
+    assert_template_result("Product: Draft 151cm ",
+                           "{% include 'product_alias' with products[0] as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+  end
+
+  def test_include_tag_for_alias
+    assert_template_result("Product: Draft 151cm Product: Element 155cm ",
+                           "{% include 'product_alias' for products as product %}", "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 +162,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 +206,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 +218,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 +248,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/liquid_tag_test.rb

@@ -81,6 +81,18 @@ class LiquidTagTest < Minitest::Test
     assert_match_syntax_error("syntax error (line 3): Unknown tag 'error'", "{% liquid echo ''\n  \n error %}")
   end
 
+  def test_nested_liquid_tag
+    assert_usage_increment("liquid_tag_contains_outer_tag", times: 0) do
+      assert_template_result('good', <<~LIQUID)
+        {%- if true %}
+          {%- liquid
+            echo "good"
+          %}
+        {%- endif -%}
+      LIQUID
+    end
+  end
+
   def test_cannot_open_blocks_living_past_a_liquid_tag
     assert_match_syntax_error("syntax error (line 3): 'if' tag was never closed", <<~LIQUID)
       {%- liquid
@@ -91,11 +103,13 @@ class LiquidTagTest < Minitest::Test
   end
 
   def test_quirk_can_close_blocks_created_before_a_liquid_tag
-    assert_template_result("42", <<~LIQUID)
-      {%- if true -%}
-      42
-      {%- liquid endif -%}
-    LIQUID
+    assert_usage_increment("liquid_tag_contains_outer_tag") do
+      assert_template_result("42", <<~LIQUID)
+        {%- if true -%}
+        42
+        {%- liquid endif -%}
+      LIQUID
+    end
   end
 
   def test_liquid_tag_in_raw

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,70 +7,44 @@ 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' %}"
-  end
-
-  def test_render_sets_the_correct_template_name_for_errors
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
-
-    with_taint_mode :error do
-      template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
-      context = Context.new('unsafe' => (+'unsafe').tap(&:taint))
-      template.render(context)
-
-      assert_equal [Liquid::TaintedError], template.errors.map(&:class)
-      assert_equal 'snippet', template.errors.first.template_name
-    end
-  end
-
-  def test_render_sets_the_correct_template_name_for_warnings
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
-
-    with_taint_mode :warn do
-      template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
-      context = Context.new('unsafe' => (+'unsafe').tap(&:taint))
-      template.render(context)
-
-      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
-      assert_equal 'snippet', context.warnings.first.template_name
-    end
+    assert_template_result('', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}")
   end
 
   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 +52,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
@@ -108,43 +82,43 @@ 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
@@ -153,7 +127,10 @@ class RenderTagTest < Minitest::Test
       'test_include' => '{% include "foo" %}'
     )
 
-    assert_template_result 'include usage is not allowed in this context', '{% render "test_include" %}'
+    exc = assert_raises(Liquid::DisabledError) do
+      Liquid::Template.parse('{% render "test_include" %}').render!
+    end
+    assert_equal('Liquid error: include usage is not allowed in this context', exc.message)
   end
 
   def test_includes_will_not_render_inside_nested_sibling_tags
@@ -163,6 +140,74 @@ class RenderTagTest < Minitest::Test
       '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" %}'
+    output = Liquid::Template.parse('{% render "nested_render_with_sibling_include" %}').render
+    assert_equal('Liquid error: include usage is not allowed in this contextLiquid error: include usage is not allowed in this context', output)
+  end
+
+  def test_render_tag_with
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
+    )
+
+    assert_template_result("Product: Draft 151cm ",
+                           "{% render 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+  end
+
+  def test_render_tag_with_alias
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
+    )
+
+    assert_template_result("Product: Draft 151cm ",
+                           "{% render 'product_alias' with products[0] as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+  end
+
+  def test_render_tag_for_alias
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
+    )
+
+    assert_template_result("Product: Draft 151cm Product: Element 155cm ",
+                           "{% render 'product_alias' for products as product %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+  end
+
+  def test_render_tag_for
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} ",
+      'product_alias' => "Product: {{ product.title }} ",
+    )
+
+    assert_template_result("Product: Draft 151cm Product: Element 155cm ",
+                           "{% render 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+  end
+
+  def test_render_tag_forloop
+    Liquid::Template.file_system = StubFileSystem.new(
+      'product' => "Product: {{ product.title }} {% if forloop.first %}first{% endif %} {% if forloop.last %}last{% endif %} index:{{ forloop.index }} ",
+    )
+
+    assert_template_result("Product: Draft 151cm first  index:1 Product: Element 155cm  last index:2 ",
+                           "{% render 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }])
+  end
+
+  def test_render_tag_for_drop
+    Liquid::Template.file_system = StubFileSystem.new(
+      'loop' => "{{ value.foo }}",
+    )
+
+    assert_template_result("123",
+                           "{% render 'loop' for loop as value %}", "loop" => TestEnumerable.new)
+  end
+
+  def test_render_tag_with_drop
+    Liquid::Template.file_system = StubFileSystem.new(
+      'loop' => "{{ value }}",
+    )
+
+    assert_template_result("TestEnumerable",
+                           "{% render 'loop' with loop as value %}", "loop" => TestEnumerable.new)
   end
 end

test/integration/tags/standard_tag_test.rb

@@ -174,13 +174,13 @@ class StandardTagTest < Minitest::Test
 
   def test_assign_from_case
     # 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 }}"
+    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,43 +51,43 @@ 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
     t = Template.new
     t.assigns['number'] = -> {
       @global ||= 0
-      @global += 1
+      @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
 
@@ -95,140 +95,140 @@ class TemplateTest < Minitest::Test
     t = Template.new
     assigns = { 'number' => -> {
                               @global ||= 0
-                              @global += 1
+                              @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,20 +238,20 @@ 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
     exception = nil
-    handler = ->(e) {
+    handler   = ->(e) {
       exception = e
       '<!-- error -->'
     }
 
     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,44 +262,44 @@ 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)
+    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)
+    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}}")
+    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
     Liquid::Template.error_mode = :strict
-    t = Template.parse("some{{x}}thing")
-    result = t.render!({ 'x' => nil }, strict_variables: true)
+    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/trim_mode_test.rb

@@ -69,7 +69,7 @@ class TrimModeTest < Minitest::Test
   # Make sure the trim isn't applied to standard tags
   def test_standard_tags
     whitespace = '          '
-    text = <<-END_TEMPLATE
+    text       = <<-END_TEMPLATE
       <div>
         <p>
           {% if true %}
@@ -110,58 +110,58 @@ class TrimModeTest < Minitest::Test
 
   # Make sure the trim isn't too agressive
   def test_no_trim_output
-    text = '<p>{{- \'John\' -}}</p>'
+    text     = '<p>{{- \'John\' -}}</p>'
     expected = '<p>John</p>'
     assert_template_result(expected, text)
   end
 
   # Make sure the trim isn't too agressive
   def test_no_trim_tags
-    text = '<p>{%- if true -%}yes{%- endif -%}</p>'
+    text     = '<p>{%- if true -%}yes{%- endif -%}</p>'
     expected = '<p>yes</p>'
     assert_template_result(expected, text)
 
-    text = '<p>{%- if false -%}no{%- endif -%}</p>'
+    text     = '<p>{%- if false -%}no{%- endif -%}</p>'
     expected = '<p></p>'
     assert_template_result(expected, text)
   end
 
   def test_single_line_outer_tag
-    text = '<p> {%- if true %} yes {% endif -%} </p>'
+    text     = '<p> {%- if true %} yes {% endif -%} </p>'
     expected = '<p> yes </p>'
     assert_template_result(expected, text)
 
-    text = '<p> {%- if false %} no {% endif -%} </p>'
+    text     = '<p> {%- if false %} no {% endif -%} </p>'
     expected = '<p></p>'
     assert_template_result(expected, text)
   end
 
   def test_single_line_inner_tag
-    text = '<p> {% if true -%} yes {%- endif %} </p>'
+    text     = '<p> {% if true -%} yes {%- endif %} </p>'
     expected = '<p> yes </p>'
     assert_template_result(expected, text)
 
-    text = '<p> {% if false -%} no {%- endif %} </p>'
+    text     = '<p> {% if false -%} no {%- endif %} </p>'
     expected = '<p>  </p>'
     assert_template_result(expected, text)
   end
 
   def test_single_line_post_tag
-    text = '<p> {% if true -%} yes {% endif -%} </p>'
+    text     = '<p> {% if true -%} yes {% endif -%} </p>'
     expected = '<p> yes </p>'
     assert_template_result(expected, text)
 
-    text = '<p> {% if false -%} no {% endif -%} </p>'
+    text     = '<p> {% if false -%} no {% endif -%} </p>'
     expected = '<p> </p>'
     assert_template_result(expected, text)
   end
 
   def test_single_line_pre_tag
-    text = '<p> {%- if true %} yes {%- endif %} </p>'
+    text     = '<p> {%- if true %} yes {%- endif %} </p>'
     expected = '<p> yes </p>'
     assert_template_result(expected, text)
 
-    text = '<p> {%- if false %} no {%- endif %} </p>'
+    text     = '<p> {%- if false %} no {%- endif %} </p>'
     expected = '<p> </p>'
     assert_template_result(expected, text)
   end
@@ -330,7 +330,7 @@ class TrimModeTest < Minitest::Test
     assert_template_result(expected, text)
 
     whitespace = '          '
-    text = <<-END_TEMPLATE
+    text       = <<-END_TEMPLATE
       <div>
         <p>
           {% if false -%}
@@ -504,7 +504,7 @@ class TrimModeTest < Minitest::Test
 
   def test_raw_output
     whitespace = '        '
-    text = <<-END_TEMPLATE
+    text       = <<-END_TEMPLATE
       <div>
         {% raw %}
           {%- if true -%}

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                 = 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                     = 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                 = 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}'" }
+    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,44 +38,55 @@ 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 assert_usage_increment(name, times: 1)
+      old_method = Liquid::Usage.method(:increment)
+      calls = 0
+      begin
+        Liquid::Usage.singleton_class.send(:remove_method, :increment)
+        Liquid::Usage.define_singleton_method(:increment) do |got_name|
+          calls += 1 if got_name == name
+          old_method.call(got_name)
+        end
+        yield
+      ensure
+        Liquid::Usage.singleton_class.send(:remove_method, :increment)
+        Liquid::Usage.define_singleton_method(:increment, old_method)
+      end
+      assert_equal(times, calls, "Number of calls to Usage.increment with #{name.inspect}")
     end
 
     def with_global_filter(*globals)
-      original_global_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
-      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
-        @filter_methods = Set.new
-      end)
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
+      original_global_filters = Liquid::StrainerFactory.instance_variable_get(:@global_filters)
+      Liquid::StrainerFactory.instance_variable_set(:@global_filters, [])
+      globals.each do |global|
+        Liquid::StrainerFactory.add_global_filter(global)
+      end
+
+      Liquid::StrainerFactory.send(:strainer_class_cache).clear
 
       globals.each do |global|
         Liquid::Template.register_filter(global)
       end
       yield
     ensure
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
-    end
-
-    def with_taint_mode(mode)
-      old_mode = Liquid::Template.taint_mode
-      Liquid::Template.taint_mode = mode
-      yield
-    ensure
-      Liquid::Template.taint_mode = old_mode
+      Liquid::StrainerFactory.send(:strainer_class_cache).clear
+      Liquid::StrainerFactory.instance_variable_set(:@global_filters, original_global_filters)
     end
 
     def with_error_mode(mode)
@@ -87,10 +98,17 @@ module Minitest
     end
 
     def with_custom_tag(tag_name, tag_class)
-      Liquid::Template.register_tag(tag_name, tag_class)
-      yield
-    ensure
-      Liquid::Template.tags.delete(tag_name)
+      old_tag = Liquid::Template.tags[tag_name]
+      begin
+        Liquid::Template.register_tag(tag_name, tag_class)
+        yield
+      ensure
+        if old_tag
+          Liquid::Template.tags[tag_name] = old_tag
+        else
+          Liquid::Template.tags.delete(tag_name)
+        end
+      end
     end
   end
 end
@@ -128,7 +146,7 @@ class StubFileSystem
 
   def initialize(values)
     @file_read_count = 0
-    @values = values
+    @values          = values
   end
 
   def read_template_file(template_path)
@@ -136,3 +154,16 @@ class StubFileSystem
     @values.fetch(template_path)
   end
 end
+
+class StubTemplateFactory
+  attr_reader :count
+
+  def initialize
+    @count = 0
+  end
+
+  def for(_template_name)
+    @count += 1
+    Liquid::Template.new
+  end
+end

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
@@ -63,7 +63,7 @@ class BlockUnitTest < Minitest::Test
 
       assert_equal 'hello', template.render
 
-      buf = +''
+      buf    = +''
       output = template.render({}, output: buf)
       assert_equal 'hello', output
       assert_equal 'hello', buf
@@ -81,7 +81,7 @@ class BlockUnitTest < Minitest::Test
 
       assert_equal 'foohellobar', template.render
 
-      buf = +''
+      buf    = +''
       output = template.render({}, output: buf)
       assert_equal 'foohellobar', output
       assert_equal 'foohellobar', buf

test/unit/condition_unit_test.rb

@@ -10,154 +10,154 @@ 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
-    @context = Liquid::Context.new
+    @context          = Liquid::Context.new
     @context['array'] = [1, 2, 3, 4, 5]
-    array_expr = VariableLookup.new("array")
+    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
 
   def test_left_or_right_may_contain_operators
-    @context = Liquid::Context.new
+    @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

@@ -46,7 +46,7 @@ end
 class CounterDrop < Liquid::Drop
   def count
     @count ||= 0
-    @count += 1
+    @count  += 1
   end
 end
 
@@ -55,9 +55,9 @@ class ArrayLike
   end
 
   def [](index)
-    @counts ||= []
+    @counts        ||= []
     @counts[index] ||= 0
-    @counts[index] += 1
+    @counts[index]  += 1
   end
 
   def to_liquid
@@ -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,177 +243,177 @@ 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' }] }
+    @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
-    @context['var'] = 'tags'
-    @context['nested'] = { 'var' => 'tags' }
+    @context['var']      = 'tags'
+    @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' }
+    @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
     @context['callcount'] = proc {
       @global ||= 0
-      @global += 1
+      @global  += 1
       @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
@@ -421,13 +421,13 @@ class ContextUnitTest < Minitest::Test
   def test_nested_lambda_is_called_once
     @context['callcount'] = { "lambda" => proc {
                                             @global ||= 0
-                                            @global += 1
+                                            @global  += 1
                                             @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
@@ -435,13 +435,13 @@ class ContextUnitTest < Minitest::Test
   def test_lambda_in_array_is_called_once
     @context['callcount'] = [1, 2, proc {
                                      @global ||= 0
-                                     @global += 1
+                                     @global  += 1
                                      @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
+    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
+    super_context   = Context.new({}, {}, {}, false, resource_limits)
+    subcontext      = super_context.new_isolated_subcontext
+    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
@@ -532,21 +532,21 @@ 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]
+    subcontext                            = super_context.new_isolated_subcontext
+    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]
+    subcontext    = super_context.new_isolated_subcontext
+    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
+    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
@@ -558,22 +558,51 @@ class ContextUnitTest < Minitest::Test
 
     super_context = Context.new
     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)
+    subcontext    = super_context.new_isolated_subcontext
+    template      = Template.parse('{{ 123 | my_filter }}')
+    assert_equal('my filter result', template.render(subcontext))
+  end
+
+  def test_disables_tag_specified
+    context = Context.new
+    context.with_disabled_tags(%w(foo bar)) do
+      assert_equal true, context.tag_disabled?("foo")
+      assert_equal true, context.tag_disabled?("bar")
+      assert_equal false, context.tag_disabled?("unknown")
+    end
+  end
+
+  def test_disables_nested_tags
+    context = Context.new
+    context.with_disabled_tags(["foo"]) do
+      context.with_disabled_tags(["foo"]) do
+        assert_equal true, context.tag_disabled?("foo")
+        assert_equal false, context.tag_disabled?("bar")
+      end
+      context.with_disabled_tags(["bar"]) do
+        assert_equal true, context.tag_disabled?("foo")
+        assert_equal true, context.tag_disabled?("bar")
+        context.with_disabled_tags(["foo"]) do
+          assert_equal true, context.tag_disabled?("foo")
+          assert_equal true, context.tag_disabled?("bar")
+        end
+      end
+      assert_equal true, context.tag_disabled?("foo")
+      assert_equal false, context.tag_disabled?("bar")
+    end
   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,12 +16,12 @@ 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
     file_system = StubFileSystem.new('my_partial' => 'some partial body')
-    context = Liquid::Context.build(
+    context     = Liquid::Context.build(
       registers: { file_system: file_system }
     )
 
@@ -33,11 +33,11 @@ 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
-    parse_context = Liquid::ParseContext.new
+    parse_context      = Liquid::ParseContext.new
     shared_file_system = StubFileSystem.new(
       'my_partial' => 'my shared value'
     )
@@ -66,12 +66,12 @@ 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
     file_system = StubFileSystem.new('my_partial' => 'some partial body')
-    context = Liquid::Context.build(
+    context     = Liquid::Context.build(
       registers: { file_system: file_system }
     )
 
@@ -88,6 +88,41 @@ 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
+
+  def test_uses_default_template_factory_when_no_template_factory_found_in_register
+    context = Liquid::Context.build(
+      registers: {
+        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
+      }
+    )
+
+    partial = Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new
+    )
+
+    assert_equal('my partial body', partial.render)
+  end
+
+  def test_uses_template_factory_register_if_present
+    template_factory = StubTemplateFactory.new
+    context = Liquid::Context.build(
+      registers: {
+        file_system: StubFileSystem.new('my_partial' => 'my partial body'),
+        template_factory: template_factory,
+      }
+    )
+
+    partial = Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new
+    )
+
+    assert_equal('my partial body', partial.render)
+    assert_equal(1, template_factory.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

@@ -1,36 +0,0 @@
-# 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

@@ -5,244 +5,152 @@ require 'test_helper'
 class StaticRegistersUnitTest < Minitest::Test
   include Liquid
 
-  def set
-    static_register = StaticRegisters.new
-    static_register[nil] = true
-    static_register[1] = :one
-    static_register[:one] = "one"
-    static_register["two"] = "three"
-    static_register["two"] = 3
-    static_register[false] = nil
+  def test_set
+    static_register = StaticRegisters.new(a: 1, b: 2)
+    static_register[:b] = 22
+    static_register[:c] = 33
 
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.registers)
-
-    static_register
+    assert_equal(1, static_register[:a])
+    assert_equal(22, static_register[:b])
+    assert_equal(33, static_register[:c])
   end
 
-  def test_get
-    static_register = set
+  def test_get_missing_key
+    static_register = StaticRegisters.new
 
-    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_nil(static_register[:missing])
   end
 
   def test_delete
-    static_register = set
+    static_register = StaticRegisters.new(a: 1, b: 2)
+    static_register[:b] = 22
+    static_register[:c] = 33
 
-    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_nil(static_register.delete(:a))
 
-    assert_equal({}, static_register.registers)
+    assert_equal(22, static_register.delete(:b))
+
+    assert_equal(33, static_register.delete(:c))
+    assert_nil(static_register[:c])
+
+    assert_nil(static_register.delete(:d))
   end
 
   def test_fetch
-    static_register = set
+    static_register = StaticRegisters.new(a: 1, b: 2)
+    static_register[:b] = 22
+    static_register[:c] = 33
 
-    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
+    assert_equal(1, static_register.fetch(:a))
+    assert_equal(1, static_register.fetch(:a, "default"))
+    assert_equal(22, static_register.fetch(:b))
+    assert_equal(22, static_register.fetch(:b, "default"))
+    assert_equal(33, static_register.fetch(:c))
+    assert_equal(33, static_register.fetch(:c, "default"))
 
-  def test_fetch_default
-    static_register = StaticRegisters.new
+    assert_raises(KeyError) do
+      static_register.fetch(:d)
+    end
+    assert_equal("default", static_register.fetch(:d, "default"))
 
-    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)
+    result = static_register.fetch(:d) { "default" }
+    assert_equal("default", result)
+
+    result = static_register.fetch(:d, "default 1") { "default 2" }
+    assert_equal("default 2", result)
   end
 
   def test_key
-    static_register = set
+    static_register = StaticRegisters.new(a: 1, b: 2)
+    static_register[:b] = 22
+    static_register[:c] = 33
 
-    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
-    static_register = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
-    static_register[nil] = false
-    static_register["two"] = 4
-    static_register[true] = "foo"
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-    assert_equal({ nil => false, "two" => 4, true => "foo" }, static_register.registers)
-
-    static_register
-  end
-
-  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]
-  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({}, static_register.registers)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-  end
-
-  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)
-  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?(:a))
+    assert_equal(true, static_register.key?(:b))
+    assert_equal(true, static_register.key?(:c))
+    assert_equal(false, static_register.key?(:d))
   end
 
   def test_static_register_can_be_frozen
-    static_register = set_with_static
+    static_register = StaticRegisters.new(a: 1)
 
-    static = static_register.static.freeze
+    static_register.static.freeze
 
     assert_raises(RuntimeError) do
-      static["two"] = "foo"
+      static_register.static[:a] = "foo"
     end
 
     assert_raises(RuntimeError) do
-      static["unknown"] = "foo"
+      static_register.static[:b] = "foo"
     end
 
     assert_raises(RuntimeError) do
-      static.delete("two")
+      static_register.static.delete(:a)
+    end
+
+    assert_raises(RuntimeError) do
+      static_register.static.delete(:c)
     end
   end
 
   def test_new_static_retains_static
-    static_register = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
-    static_register["one"] = 1
-    static_register["two"] = 2
-    static_register["three"] = 3
+    static_register = StaticRegisters.new(a: 1, b: 2)
+    static_register[:b] = 22
+    static_register[:c] = 33
 
-    new_register = StaticRegisters.new(static_register)
-    assert_equal({}, new_register.registers)
+    new_static_register = StaticRegisters.new(static_register)
+    new_static_register[:b] = 222
 
-    new_register["one"] = 4
-    new_register["two"] = 5
-    new_register["three"] = 6
+    newest_static_register = StaticRegisters.new(new_static_register)
+    newest_static_register[:c] = 333
 
-    newest_register = StaticRegisters.new(new_register)
-    assert_equal({}, newest_register.registers)
+    assert_equal(1, static_register[:a])
+    assert_equal(22, static_register[:b])
+    assert_equal(33, static_register[:c])
 
-    newest_register["one"] = 7
-    newest_register["two"] = 8
-    newest_register["three"] = 9
+    assert_equal(1, new_static_register[:a])
+    assert_equal(222, new_static_register[:b])
+    assert_nil(new_static_register[:c])
 
-    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
-    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
-    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, new_register.static)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, newest_register.static)
+    assert_equal(1, newest_static_register[:a])
+    assert_equal(2, newest_static_register[:b])
+    assert_equal(333, newest_static_register[:c])
   end
 
   def test_multiple_instances_are_unique
-    static_register = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
-    static_register["one"] = 1
-    static_register["two"] = 2
-    static_register["three"] = 3
+    static_register_1 = StaticRegisters.new(a: 1, b: 2)
+    static_register_1[:b] = 22
+    static_register_1[:c] = 33
 
-    new_register = StaticRegisters.new(foo: :bar)
-    assert_equal({}, new_register.registers)
+    static_register_2 = StaticRegisters.new(a: 10, b: 20)
+    static_register_2[:b] = 220
+    static_register_2[:c] = 330
 
-    new_register["one"] = 4
-    new_register["two"] = 5
-    new_register["three"] = 6
+    assert_equal({ a: 1, b: 2 }, static_register_1.static)
+    assert_equal(1, static_register_1[:a])
+    assert_equal(22, static_register_1[:b])
+    assert_equal(33, static_register_1[:c])
 
-    newest_register = StaticRegisters.new(bar: :foo)
-    assert_equal({}, newest_register.registers)
-
-    newest_register["one"] = 7
-    newest_register["two"] = 8
-    newest_register["three"] = 9
-
-    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
-    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
-    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
-    assert_equal({ foo: :bar }, new_register.static)
-    assert_equal({ bar: :foo }, newest_register.static)
+    assert_equal({ a: 10, b: 20 }, static_register_2.static)
+    assert_equal(10, static_register_2[:a])
+    assert_equal(220, static_register_2[:b])
+    assert_equal(330, static_register_2[:c])
   end
 
-  def test_can_update_static_directly_and_updates_all_instances
-    static_register = StaticRegisters.new(nil => true, 1 => :one, :one => "one", "two" => 3, false => nil)
-    static_register["one"] = 1
-    static_register["two"] = 2
-    static_register["three"] = 3
+  def test_initialization_reused_static_same_memory_object
+    static_register_1 = StaticRegisters.new(a: 1, b: 2)
+    static_register_1[:b] = 22
+    static_register_1[:c] = 33
 
-    new_register = StaticRegisters.new(static_register)
-    assert_equal({}, new_register.registers)
+    static_register_2 = StaticRegisters.new(static_register_1)
 
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil }, static_register.static)
+    assert_equal(1, static_register_2[:a])
+    assert_equal(2, static_register_2[:b])
+    assert_nil(static_register_2[:c])
 
-    new_register["one"] = 4
-    new_register["two"] = 5
-    new_register["three"] = 6
-    new_register.static["four"] = 10
+    static_register_1.static[:b] = 222
+    static_register_1.static[:c] = 333
 
-    newest_register = StaticRegisters.new(new_register)
-    assert_equal({}, newest_register.registers)
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 10 }, new_register.static)
-
-    newest_register["one"] = 7
-    newest_register["two"] = 8
-    newest_register["three"] = 9
-    new_register.static["four"] = 5
-    new_register.static["five"] = 15
-
-    assert_equal({ "one" => 1, "two" => 2, "three" => 3 }, static_register.registers)
-    assert_equal({ "one" => 4, "two" => 5, "three" => 6 }, new_register.registers)
-    assert_equal({ "one" => 7, "two" => 8, "three" => 9 }, newest_register.registers)
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, newest_register.static)
-
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, static_register.static)
-    assert_equal({ nil => true, 1 => :one, :one => "one", "two" => 3, false => nil, "four" => 5, "five" => 15 }, new_register.static)
+    assert_same(static_register_1.static, static_register_2.static)
   end
 end

test/unit/strainer_factory_unit_test.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class StrainerFactoryUnitTest < Minitest::Test
+  include Liquid
+
+  module AccessScopeFilters
+    def public_filter(_input)
+      "public"
+    end
+
+    def private_filter(_input)
+      "private"
+    end
+    private :private_filter
+  end
+
+  StrainerFactory.add_global_filter(AccessScopeFilters)
+
+  module LateAddedFilter
+    def late_added_filter(_input)
+      "filtered"
+    end
+  end
+
+  def setup
+    @context = Context.build
+  end
+
+  def test_strainer
+    strainer = StrainerFactory.create(@context)
+    assert_equal(5, strainer.invoke('size', 'input'))
+    assert_equal("public", strainer.invoke("public_filter", 'input'))
+  end
+
+  def test_stainer_raises_argument_error
+    strainer = StrainerFactory.create(@context)
+    assert_raises(Liquid::ArgumentError) do
+      strainer.invoke("public_filter", 'input', 1)
+    end
+  end
+
+  def test_stainer_argument_error_contains_backtrace
+    strainer = StrainerFactory.create(@context)
+
+    exception = assert_raises(Liquid::ArgumentError) do
+      strainer.invoke("public_filter", 'input', 1)
+    end
+
+    assert_match(
+      /\ALiquid error: wrong number of arguments \((2 for 1|given 2, expected 1)\)\z/,
+      exception.message
+    )
+    assert_equal(exception.backtrace[0].split(':')[0], __FILE__)
+  end
+
+  def test_strainer_only_invokes_public_filter_methods
+    strainer = StrainerFactory.create(@context)
+    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 = StrainerFactory.create(@context)
+    assert_nil(strainer.invoke("private_filter", nil))
+    assert_nil(strainer.invoke("undef_the_filter", nil))
+  end
+
+  def test_strainer_returns_first_argument_if_no_method_and_arguments_given
+    strainer = StrainerFactory.create(@context)
+    assert_equal("password", strainer.invoke("undef_the_method", "password"))
+  end
+
+  def test_strainer_only_allows_methods_defined_in_filters
+    strainer = StrainerFactory.create(@context)
+    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 = StrainerFactory.create(@context, [a, b])
+    assert_kind_of(StrainerTemplate, strainer)
+    assert_kind_of(a, strainer)
+    assert_kind_of(b, strainer)
+    assert_kind_of(Liquid::StandardFilters, strainer)
+  end
+
+  def test_add_global_filter_clears_cache
+    assert_equal('input', StrainerFactory.create(@context).invoke('late_added_filter', 'input'))
+    StrainerFactory.add_global_filter(LateAddedFilter)
+    assert_equal('filtered', StrainerFactory.create(nil).invoke('late_added_filter', 'input'))
+  end
+end

test/unit/strainer_template_unit_test.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class StrainerTemplateUnitTest < Minitest::Test
+  include Liquid
+
+  def test_add_filter_when_wrong_filter_class
+    c = Context.new
+    s = c.strainer
+    wrong_filter = ->(v) { v.reverse }
+
+    exception = assert_raises(TypeError) do
+      s.class.add_filter(wrong_filter)
+    end
+    assert_equal(exception.message, "wrong argument type Proc (expected Module)")
+  end
+
+  module PrivateMethodOverrideFilter
+    private
+
+    def public_filter
+      "overriden as private"
+    end
+  end
+
+  def test_add_filter_raises_when_module_privately_overrides_registered_public_methods
+    strainer = Context.new.strainer
+
+    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)
+  end
+
+  module ProtectedMethodOverrideFilter
+    protected
+
+    def public_filter
+      "overriden as protected"
+    end
+  end
+
+  def test_add_filter_raises_when_module_overrides_registered_public_method_as_protected
+    strainer = Context.new.strainer
+
+    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)
+  end
+
+  module PublicMethodOverrideFilter
+    def public_filter
+      "public"
+    end
+  end
+
+  def test_add_filter_does_not_raise_when_module_overrides_previously_registered_method
+    strainer = Context.new.strainer
+    with_global_filter do
+      strainer.class.add_filter(PublicMethodOverrideFilter)
+      assert(strainer.class.send(:filter_methods).include?(:public_filter))
+    end
+  end
+
+  def test_add_filter_does_not_include_already_included_module
+    mod = Module.new do
+      class << self
+        attr_accessor :include_count
+        def included(_mod)
+          self.include_count += 1
+        end
+      end
+      self.include_count = 0
+    end
+    strainer = Context.new.strainer
+    strainer.class.add_filter(mod)
+    strainer.class.add_filter(mod)
+    assert_equal(1, mod.include_count)
+  end
+end

test/unit/strainer_unit_test.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class StrainerUnitTest < Minitest::Test
-  include Liquid
-
-  module AccessScopeFilters
-    def public_filter
-      "public"
-    end
-
-    def private_filter
-      "private"
-    end
-    private :private_filter
-  end
-
-  Strainer.global_filter(AccessScopeFilters)
-
-  def test_strainer
-    strainer = Strainer.create(nil)
-    assert_equal 5, strainer.invoke('size', 'input')
-    assert_equal "public", strainer.invoke("public_filter")
-  end
-
-  def test_stainer_raises_argument_error
-    strainer = Strainer.create(nil)
-    assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
-    end
-  end
-
-  def test_stainer_argument_error_contains_backtrace
-    strainer = Strainer.create(nil)
-    begin
-      strainer.invoke("public_filter", 1)
-    rescue Liquid::ArgumentError => e
-      assert_match(
-        /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/,
-        e.message
-      )
-      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
-  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")
-  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")
-  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")
-  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
-  end
-
-  def test_add_filter_when_wrong_filter_class
-    c = Context.new
-    s = c.strainer
-    wrong_filter = ->(v) { v.reverse }
-
-    assert_raises ArgumentError do
-      s.class.add_filter(wrong_filter)
-    end
-  end
-
-  module PrivateMethodOverrideFilter
-    private
-
-    def public_filter
-      "overriden as private"
-    end
-  end
-
-  def test_add_filter_raises_when_module_privately_overrides_registered_public_methods
-    strainer = Context.new.strainer
-
-    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
-  end
-
-  module ProtectedMethodOverrideFilter
-    protected
-
-    def public_filter
-      "overriden as protected"
-    end
-  end
-
-  def test_add_filter_raises_when_module_overrides_registered_public_method_as_protected
-    strainer = Context.new.strainer
-
-    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
-  end
-
-  module PublicMethodOverrideFilter
-    def public_filter
-      "public"
-    end
-  end
-
-  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')
-  end
-
-  module LateAddedFilter
-    def late_added_filter(_input)
-      "filtered"
-    end
-  end
-
-  def test_global_filter_clears_cache
-    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')
-  end
-
-  def test_add_filter_does_not_include_already_included_module
-    mod = Module.new do
-      class << self
-        attr_accessor :include_count
-        def included(_mod)
-          self.include_count += 1
-        end
-      end
-      self.include_count = 0
-    end
-    strainer = Context.new.strainer
-    strainer.class.add_filter(mod)
-    strainer.class.add_filter(mod)
-    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
@@ -33,7 +33,7 @@ class TagUnitTest < Minitest::Test
 
       assert_equal 'hello', template.render
 
-      buf = +''
+      buf    = +''
       output = template.render({}, output: buf)
       assert_equal 'hello', output
       assert_equal 'hello', buf
@@ -51,7 +51,7 @@ class TagUnitTest < Minitest::Test
 
       assert_equal 'foohellobar', template.render
 
-      buf = +''
+      buf    = +''
       output = template.render({}, output: buf)
       assert_equal 'foohellobar', output
       assert_equal 'foohellobar', buf