Merge branch 'master' into fix-constants

Align equals operator in `lib/liquid/legacy.rb`

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

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

.rubocop_todo.yml

@@ -18,28 +18,9 @@ Lint/InheritException:
 # Cop supports --auto-correct.
 # Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
-Layout/LineLength:
+Metrics/LineLength:
   Max: 294
 
-# Offense count: 44
-Naming/ConstantName:
-  Exclude:
-    - 'lib/liquid.rb'
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/tags/assign.rb'
-    - 'lib/liquid/tags/capture.rb'
-    - 'lib/liquid/tags/case.rb'
-    - 'lib/liquid/tags/cycle.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/tags/include.rb'
-    - 'lib/liquid/tags/raw.rb'
-    - 'lib/liquid/tags/table_row.rb'
-    - 'lib/liquid/variable.rb'
-    - 'performance/shopify/comment_form.rb'
-    - 'performance/shopify/paginate.rb'
-    - 'test/integration/tags/include_tag_test.rb'
-
 # Offense count: 5
 Style/ClassVars:
   Exclude:

.travis.yml

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

Gemfile

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

History.md

@@ -1,11 +1,5 @@
 # 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

lib/liquid.rb

@@ -22,25 +22,25 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 module Liquid
-  FilterSeparator             = /\|/
-  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'
-  WhitespaceControl           = '-'
-  TagStart                    = /\{\%/
-  TagEnd                      = /\%\}/
-  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
-  VariableSegment             = /[\w\-]/
-  VariableStart               = /\{\{/
-  VariableEnd                 = /\}\}/
-  VariableIncompleteEnd       = /\}\}?/
-  QuotedString                = /"[^"]*"|'[^']*'/
-  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
-  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
-  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
-  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
-  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
+  FILTER_SEPARATOR             = /\|/
+  ARGUMENT_SEPARATOR           = ','
+  FILTER_ARGUMENT_SEPARATOR    = ':'
+  VARIABLE_ATTRIBUTE_SEPARATOR = '.'
+  WHITESPACE_CONTROL           = '-'
+  TAG_START                    = /\{\%/
+  TAG_END                      = /\%\}/
+  VARIABLE_SIGNATURE           = /\(?[\w\-\.\[\]]\)?/
+  VARIABLE_SEGMENT             = /[\w\-]/
+  VARIABLE_START               = /\{\{/
+  VARIABLE_END                 = /\}\}/
+  VARIABLE_INCOMPLETE_END      = /\}\}?/
+  QUOTED_STRING                = /"[^"]*"|'[^']*'/
+  QUOTED_FRAGMENT              = /#{QUOTED_STRING}|(?:[^\s,\|'"]|#{QUOTED_STRING})+/o
+  TAG_ATTRIBUTES               = /(\w+)\s*\:\s*(#{QUOTED_FRAGMENT})/o
+  ANY_STARTING_TAG             = /#{TAG_START}|#{VARIABLE_START}/o
+  PARTIAL_TEMPLATE_PARSER      = /#{TAG_START}.*?#{TAG_END}|#{VARIABLE_START}.*?#{VARIABLE_INCOMPLETE_END}/om
+  TEMPLATE_PARSER              = /(#{PARTIAL_TEMPLATE_PARSER}|#{ANY_STARTING_TAG})/om
+  VARIABLE_PARSER              = /\[[^\]]+\]|#{VARIABLE_SEGMENT}+\??/o
 
   singleton_class.send(:attr_accessor, :cache_classes)
   self.cache_classes = true
@@ -57,14 +57,11 @@ require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer_factory'
-require 'liquid/strainer_template'
+require 'liquid/strainer'
 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'
@@ -83,8 +80,10 @@ 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 }
+
+require 'liquid/legacy'

lib/liquid/block_body.rb

@@ -1,15 +1,13 @@
 # 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
-    WhitespaceOrNothing = /\A\s*\z/
-    TAGSTART            = "{%"
-    VARSTART            = "{{"
+    LIQUID_TAG_TOKEN      = /\A\s*(\w+)\s*(.*?)\z/o
+    FULL_TOKEN            = /\A#{TAG_START}#{WHITESPACE_CONTROL}?(\s*)(\w+)(\s*)(.*?)#{WHITESPACE_CONTROL}?#{TAG_END}\z/om
+    CONTENT_OF_VARIABLE   = /\A#{VARIABLE_START}#{WHITESPACE_CONTROL}?(.*?)#{WHITESPACE_CONTROL}?#{VARIABLE_END}\z/om
+    WHITESPACE_OR_NOTHING = /\A\s*\z/
+    TAG_START_STRING      = "{%"
+    VAR_START_STRING      = "{{"
 
     attr_reader :nodelist
 
@@ -30,8 +28,8 @@ module Liquid
 
     private def parse_for_liquid_tag(tokenizer, parse_context)
       while (token = tokenizer.shift)
-        unless token.empty? || token =~ WhitespaceOrNothing
-          unless token =~ LiquidTagToken
+        unless token.empty? || token =~ WHITESPACE_OR_NOTHING
+          unless token =~ LIQUID_TAG_TOKEN
             # line isn't empty but didn't match tag syntax, yield and let the
             # caller raise a syntax error
             return yield token, token
@@ -53,28 +51,13 @@ 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?
         case
-        when token.start_with?(TAGSTART)
+        when token.start_with?(TAG_START_STRING)
           whitespace_handler(token, parse_context)
-          unless token =~ FullToken
+          unless token =~ FULL_TOKEN
             raise_missing_tag_terminator(token, parse_context)
           end
           tag_name = Regexp.last_match(2)
@@ -87,8 +70,8 @@ module Liquid
           end
 
           if tag_name == 'liquid'
-            parse_liquid_tag(markup, parse_context, &block)
-            next
+            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)
           end
 
           unless (tag = registered_tags[tag_name])
@@ -99,7 +82,7 @@ module Liquid
           new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
           @blank &&= new_tag.blank?
           @nodelist << new_tag
-        when token.start_with?(VARSTART)
+        when token.start_with?(VAR_START_STRING)
           whitespace_handler(token, parse_context)
           @nodelist << create_variable(token, parse_context)
           @blank = false
@@ -109,7 +92,7 @@ module Liquid
           end
           parse_context.trim_whitespace = false
           @nodelist << token
-          @blank &&= !!(token =~ WhitespaceOrNothing)
+          @blank &&= !!(token =~ WHITESPACE_OR_NOTHING)
         end
         parse_context.line_number = tokenizer.line_number
       end
@@ -118,13 +101,13 @@ module Liquid
     end
 
     def whitespace_handler(token, parse_context)
-      if token[2] == WhitespaceControl
+      if token[2] == WHITESPACE_CONTROL
         previous_token = @nodelist.last
         if previous_token.is_a?(String)
           previous_token.rstrip!
         end
       end
-      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
+      parse_context.trim_whitespace = (token[-3] == WHITESPACE_CONTROL)
     end
 
     def blank?
@@ -171,7 +154,13 @@ module Liquid
     private
 
     def render_node(context, output, node)
-      node.render_to_output_buffer(context, output)
+      if node.disabled?(context)
+        output << node.disabled_error_message
+        return
+      end
+      disable_tags(context, node.disabled_tags) do
+        node.render_to_output_buffer(context, output)
+      end
     rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
       context.handle_error(e, node.line_number)
     rescue ::StandardError => e
@@ -179,6 +168,11 @@ module Liquid
       output << context.handle_error(e, line_number)
     end
 
+    def disable_tags(context, tags, &block)
+      return yield if tags.empty?
+      context.registers[:disabled_tags].disable(tags, &block)
+    end
+
     def raise_if_resource_limits_reached(context, length)
       context.resource_limits.render_length += length
       return unless context.resource_limits.reached?
@@ -186,7 +180,7 @@ module Liquid
     end
 
     def create_variable(token, parse_context)
-      token.scan(ContentOfVariable) do |content|
+      token.scan(CONTENT_OF_VARIABLE) do |content|
         markup = content.first
         return Variable.new(markup, parse_context)
       end
@@ -194,11 +188,11 @@ module Liquid
     end
 
     def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TAG_END.inspect)
     end
 
     def raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VARIABLE_END.inspect)
     end
 
     def registered_tags

lib/liquid/context.rb

@@ -44,7 +44,6 @@ module Liquid
       @interrupts    = []
       @filters       = []
       @global_filter = nil
-      @disabled_tags = {}
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -53,7 +52,7 @@ module Liquid
     end
 
     def strainer
-      @strainer ||= StrainerFactory.create(self, @filters)
+      @strainer ||= Strainer.create(self, @filters)
     end
 
     # Adds filters to this context.
@@ -145,7 +144,6 @@ module Liquid
         subcontext.strainer = nil
         subcontext.errors   = errors
         subcontext.warnings = warnings
-        subcontext.disabled_tags = @disabled_tags
       end
     end
 
@@ -210,24 +208,9 @@ 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, :disabled_tags
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
 
     private
 

lib/liquid/errors.rb

@@ -46,6 +46,7 @@ module Liquid
   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)
@@ -53,6 +54,5 @@ module Liquid
   UndefinedDropMethod = Class.new(Error)
   UndefinedFilter     = Class.new(Error)
   MethodOverrideError = Class.new(Error)
-  DisabledError       = Class.new(Error)
   InternalError       = Class.new(Error)
 end

lib/liquid/legacy.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Liquid
+  FilterSeparator            = FILTER_SEPARATOR
+  ArgumentSeparator          = ARGUMENT_SEPARATOR
+  FilterArgumentSeparator    = FILTER_ARGUMENT_SEPARATOR
+  VariableAttributeSeparator = VARIABLE_ATTRIBUTE_SEPARATOR
+  WhitespaceControl          = WHITESPACE_CONTROL
+  TagStart                   = TAG_START
+  TagEnd                     = TAG_END
+  VariableSignature          = VARIABLE_SIGNATURE
+  VariableSegment            = VARIABLE_SEGMENT
+  VariableStart              = VARIABLE_START
+  VariableEnd                = VARIABLE_END
+  VariableIncompleteEnd      = VARIABLE_INCOMPLETE_END
+  QuotedString               = QUOTED_STRING
+  QuotedFragment             = QUOTED_FRAGMENT
+  TagAttributes              = TAG_ATTRIBUTES
+  AnyStartingTag             = ANY_STARTING_TAG
+  PartialTemplateParser      = PARTIAL_TEMPLATE_PARSER
+  TemplateParser             = TEMPLATE_PARSER
+  VariableParser             = VARIABLE_PARSER
+
+  class BlockBody
+    FullToken           = FULL_TOKEN
+    ContentOfVariable   = CONTENT_OF_VARIABLE
+    WhitespaceOrNothing = WHITESPACE_OR_NOTHING
+    TAGSTART            = TAG_START_STRING
+    VARSTART            = VAR_START_STRING
+  end
+
+  class Assign < Tag
+    Syntax = SYNTAX
+  end
+
+  class Capture < Block
+    Syntax = SYNTAX
+  end
+
+  class Case < Block
+    Syntax     = SYNTAX
+    WhenSyntax = WHEN_SYNTAX
+  end
+
+  class Cycle < Tag
+    SimpleSyntax = SIMPLE_SYNTAX
+    NamedSyntax  = NAMED_SYNTAX
+  end
+
+  class For < Block
+    Syntax = SYNTAX
+  end
+
+  class If < Block
+    Syntax                  = SYNTAX
+    ExpressionsAndOperators = EXPRESSIONS_AND_OPERATORS
+  end
+
+  class Include < Tag
+    Syntax = SYNTAX
+  end
+
+  class Raw < Block
+    Syntax                   = SYNTAX
+    FullTokenPossiblyInvalid = FULL_TOKEN_POSSIBLY_INVALID
+  end
+
+  class TableRow < Block
+    Syntax = SYNTAX
+  end
+
+  class Variable
+    FilterMarkupRegex        = FILTER_MARKUP_REGEX
+    FilterParser             = FILTER_PARSER
+    FilterArgsRegex          = FILTER_ARGS_REGEX
+    JustTagAttributes        = JUST_TAG_ATTRIBUTES
+    MarkupWithQuotedFragment = MARKUP_WITH_QUOTED_FRAGMENT
+  end
+end

lib/liquid/parser_switching.rb

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

lib/liquid/partial_cache.rb

@@ -12,10 +12,7 @@ module Liquid
 
       parse_context.partial = true
 
-      template_factory = (context.registers[:template_factory] ||= Liquid::TemplateFactory.new)
-      template = template_factory.for(template_name)
-
-      partial = template.parse(source, parse_context)
+      partial = Liquid::Template.parse(source, parse_context)
       cached_partials[template_name] = partial
     ensure
       parse_context.partial = false

lib/liquid/profiler/hooks.rb

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

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

lib/liquid/standardfilters.rb

@@ -41,7 +41,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input.to_s) unless input.nil?
+      CGI.escapeHTML(input.to_s).untaint unless input.nil?
     end
     alias_method :h, :escape
 

lib/liquid/static_registers.rb

@@ -2,7 +2,7 @@
 
 module Liquid
   class StaticRegisters
-    attr_reader :static
+    attr_reader :static, :registers
 
     def initialize(registers = {})
       @static    = registers.is_a?(StaticRegisters) ? registers.static : registers
@@ -25,16 +25,8 @@ module Liquid
       @registers.delete(key)
     end
 
-    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
+    def fetch(key, default = nil)
+      key?(key) ? self[key] : default
     end
 
     def key?(key)

lib/liquid/strainer.rb

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

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

@@ -1,53 +0,0 @@
-# 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.public_instance_methods.each { |name| filter_methods[name] = true }
-      end
-
-      def invokable?(method)
-        filter_methods.key?(method.to_sym)
-      end
-
-      private
-
-      def filter_methods
-        @filter_methods ||= {}
-      end
-    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/tag.rb

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

lib/liquid/tag/disableable.rb

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

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

@@ -10,17 +10,21 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
+    SYNTAX = /(#{VARIABLE_SIGNATURE}+)\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)
+      if markup =~ SYNTAX
+        @to = Regexp.last_match(1)
         @from = Variable.new(Regexp.last_match(2), options)
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.assign')
+        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
       end
     end
 

lib/liquid/tags/capture.rb

@@ -13,11 +13,11 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    Syntax = /(#{VariableSignature}+)/o
+    SYNTAX = /(#{VARIABLE_SIGNATURE}+)/o
 
     def initialize(tag_name, markup, options)
       super
-      if markup =~ Syntax
+      if markup =~ SYNTAX
         @to = Regexp.last_match(1)
       else
         raise SyntaxError, options[:locale].t("errors.syntax.capture")

lib/liquid/tags/case.rb

@@ -2,8 +2,8 @@
 
 module Liquid
   class Case < Block
-    Syntax     = /(#{QuotedFragment})/o
-    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
+    SYNTAX = /(#{QUOTED_FRAGMENT})/o
+    WHEN_SYNTAX = /(#{QUOTED_FRAGMENT})(?:(?:\s+or\s+|\s*\,\s*)(#{QUOTED_FRAGMENT}.*))?/om
 
     attr_reader :blocks, :left
 
@@ -11,7 +11,7 @@ module Liquid
       super
       @blocks = []
 
-      if markup =~ Syntax
+      if markup =~ SYNTAX
         @left = Expression.parse(Regexp.last_match(1))
       else
         raise SyntaxError, options[:locale].t("errors.syntax.case")
@@ -59,7 +59,7 @@ module Liquid
       body = BlockBody.new
 
       while markup
-        unless markup =~ WhenSyntax
+        unless markup =~ WHEN_SYNTAX
           raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
         end
 

lib/liquid/tags/cycle.rb

@@ -14,18 +14,18 @@ module Liquid
   #    <div class="green"> Item five</div>
   #
   class Cycle < Tag
-    SimpleSyntax = /\A#{QuotedFragment}+/o
-    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
+    SIMPLE_SYNTAX = /\A#{QUOTED_FRAGMENT}+/o
+    NAMED_SYNTAX  = /\A(#{QUOTED_FRAGMENT})\s*\:\s*(.*)/om
 
     attr_reader :variables
 
     def initialize(tag_name, markup, options)
       super
       case markup
-      when NamedSyntax
+      when NAMED_SYNTAX
         @variables = variables_from_string(Regexp.last_match(2))
         @name      = Expression.parse(Regexp.last_match(1))
-      when SimpleSyntax
+      when SIMPLE_SYNTAX
         @variables = variables_from_string(markup)
         @name      = @variables.to_s
       else
@@ -60,7 +60,7 @@ module Liquid
 
     def variables_from_string(markup)
       markup.split(',').collect do |var|
-        var =~ /\s*(#{QuotedFragment})\s*/o
+        var =~ /\s*(#{QUOTED_FRAGMENT})\s*/o
         Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
       end.compact
     end

lib/liquid/tags/for.rb

@@ -46,7 +46,7 @@ module Liquid
   # forloop.parentloop:: Provides access to the parent loop, if present.
   #
   class For < Block
-    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
+    SYNTAX = /\A(#{VARIABLE_SEGMENT}+)\s+in\s+(#{QUOTED_FRAGMENT}+)\s*(reversed)?/o
 
     attr_reader :collection_name, :variable_name, :limit, :from
 
@@ -87,13 +87,13 @@ module Liquid
     protected
 
     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}"
+      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}"
         @collection_name = Expression.parse(collection_name)
-        markup.scan(TagAttributes) do |key, value|
+        markup.scan(TAG_ATTRIBUTES) do |key, value|
           set_attribute(key, value)
         end
       else

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
-    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
+    SYNTAX                    = /(#{QUOTED_FRAGMENT})\s*([=!<>a-z_]+)?\s*(#{QUOTED_FRAGMENT})?/o
+    EXPRESSIONS_AND_OPERATORS = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QUOTED_FRAGMENT}|\S+)\s*)+)/o
+    BOOLEAN_OPERATORS         = %w(and or).freeze
 
     attr_reader :blocks
 
@@ -65,15 +65,15 @@ module Liquid
     end
 
     def lax_parse(markup)
-      expressions = markup.scan(ExpressionsAndOperators)
-      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
+      expressions = markup.scan(EXPRESSIONS_AND_OPERATORS)
+      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ SYNTAX
 
       condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
 
       until expressions.empty?
         operator = expressions.pop.to_s.strip
 
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ SYNTAX
 
         new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
         raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)

lib/liquid/tags/include.rb

@@ -16,10 +16,7 @@ module Liquid
   #   {% include 'product' for products %}
   #
   class Include < Tag
-    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
 
@@ -36,7 +33,7 @@ module Liquid
         @template_name_expr = Expression.parse(template_name)
         @attributes         = {}
 
-        markup.scan(TagAttributes) do |key, value|
+        markup.scan(TAG_ATTRIBUTES) do |key, value|
           @attributes[key] = Expression.parse(value)
         end
 

lib/liquid/tags/raw.rb

@@ -2,8 +2,8 @@
 
 module Liquid
   class Raw < Block
-    Syntax = /\A\s*\z/
-    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    SYNTAX = /\A\s*\z/
+    FULL_TOKEN_POSSIBLY_INVALID = /\A(.*)#{TAG_START}\s*(\w+)\s*(.*)?#{TAG_END}\z/om
 
     def initialize(tag_name, markup, parse_context)
       super
@@ -14,7 +14,7 @@ module Liquid
     def parse(tokens)
       @body = +''
       while (token = tokens.shift)
-        if token =~ FullTokenPossiblyInvalid
+        if token =~ FULL_TOKEN_POSSIBLY_INVALID
           @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
           return if block_delimiter == Regexp.last_match(2)
         end
@@ -40,7 +40,7 @@ module Liquid
     protected
 
     def ensure_valid_markup(tag_name, markup, parse_context)
-      unless Syntax.match?(markup)
+      unless SYNTAX.match?(markup)
         raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args", tag: tag_name)
       end
     end

lib/liquid/tags/render.rb

@@ -2,8 +2,7 @@
 
 module Liquid
   class Render < Tag
-    FOR = 'for'
-    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    SYNTAX = /(#{QuotedString}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
 
     disable_tags "include"
 
@@ -15,16 +14,14 @@ 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)
+      variable_name = Regexp.last_match(3)
 
-      @alias_name = Regexp.last_match(6)
+      @alias_name = Regexp.last_match(5)
       @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|
+      markup.scan(TAG_ATTRIBUTES) do |key, value|
         @attributes[key] = Expression.parse(value)
       end
     end
@@ -61,7 +58,7 @@ module Liquid
       }
 
       variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
-      if @for && variable.respond_to?(:each) && variable.respond_to?(:count)
+      if variable.is_a?(Array)
         forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
         variable.each { |var| render_partial_func.call(var, forloop) }
       else

lib/liquid/tags/table_row.rb

@@ -2,17 +2,17 @@
 
 module Liquid
   class TableRow < Block
-    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
+    SYNTAX = /(\w+)\s+in\s+(#{QUOTED_FRAGMENT}+)/o
 
     attr_reader :variable_name, :collection_name, :attributes
 
     def initialize(tag_name, markup, options)
       super
-      if markup =~ Syntax
+      if markup =~ SYNTAX
         @variable_name   = Regexp.last_match(1)
         @collection_name = Expression.parse(Regexp.last_match(2))
         @attributes      = {}
-        markup.scan(TagAttributes) do |key, value|
+        markup.scan(TAG_ATTRIBUTES) do |key, value|
           @attributes[key] = Expression.parse(value)
         end
       else

lib/liquid/template.rb

@@ -18,6 +18,8 @@ module Liquid
     attr_accessor :root
     attr_reader :resource_limits, :warnings
 
+    @@file_system = BlankFileSystem.new
+
     class TagRegistry
       include Enumerable
 
@@ -61,46 +63,73 @@ 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_accessor :error_mode
-      Template.error_mode = :lax
+      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 :default_exception_renderer
       Template.default_exception_renderer = lambda do |exception|
         exception
       end
 
-      attr_accessor :file_system
-      Template.file_system = BlankFileSystem.new
+      def file_system
+        @@file_system
+      end
 
-      attr_accessor :tags
-      Template.tags = TagRegistry.new
-      private :tags=
+      def file_system=(obj)
+        @@file_system = obj
+      end
 
       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)
-        StrainerFactory.add_global_filter(mod)
+        Strainer.global_filter(mod)
       end
 
-      attr_accessor :default_resource_limits
-      Template.default_resource_limits = {}
-      private :default_resource_limits=
+      def default_resource_limits
+        @default_resource_limits ||= {}
+      end
 
       # 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 = {})
-        new.parse(source, options)
+        template = Template.new
+        template.parse(source, options)
       end
     end
 
     def initialize
       @rethrow_errors  = false
-      @resource_limits = ResourceLimits.new(Template.default_resource_limits)
+      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
     end
 
     # Parse source code.
@@ -186,6 +215,10 @@ 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
 

lib/liquid/template_factory.rb

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

lib/liquid/tokenizer.rb

@@ -28,7 +28,7 @@ module Liquid
 
       return @source.split("\n") if @for_liquid_tag
 
-      tokens = @source.split(TemplateParser)
+      tokens = @source.split(TEMPLATE_PARSER)
 
       # removes the rogue empty element at the beginning of the array
       tokens.shift if tokens[0]&.empty?

lib/liquid/variable.rb

@@ -12,11 +12,11 @@ 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
-    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
+    FILTER_MARKUP_REGEX         = /#{FILTER_SEPARATOR}\s*(.*)/om
+    FILTER_PARSER               = /(?:\s+|#{QUOTED_FRAGMENT}|#{ARGUMENT_SEPARATOR})+/o
+    FILTER_ARGS_REGEX .         = /(?:#{FILTER_ARGUMENT_SEPARATOR}|#{ARGUMENT_SEPARATOR})\s*((?:\w+\s*\:\s*)?#{QUOTED_FRAGMENT})/o
+    JUST_TAG_ATTRIBUTES         = /\A#{TAG_ATTRIBUTES}\z/o
+    MARKUP_WITH_QUOTED_FRAGMENT = /(#{QUOTED_FRAGMENT})(.*)/om
 
     attr_accessor :filters, :name, :line_number
     attr_reader :parse_context
@@ -43,17 +43,17 @@ module Liquid
 
     def lax_parse(markup)
       @filters = []
-      return unless markup =~ MarkupWithQuotedFragment
+      return unless markup =~ MARKUP_WITH_QUOTED_FRAGMENT
 
       name_markup   = Regexp.last_match(1)
       filter_markup = Regexp.last_match(2)
       @name         = Expression.parse(name_markup)
-      if filter_markup =~ FilterMarkupRegex
-        filters = Regexp.last_match(1).scan(FilterParser)
+      if filter_markup =~ FILTER_MARKUP_REGEX
+        filters = Regexp.last_match(1).scan(FILTER_PARSER)
         filters.each do |f|
           next unless f =~ /\w+/
           filtername = Regexp.last_match(0)
-          filterargs = f.scan(FilterArgsRegex).flatten
+          filterargs = f.scan(FILTER_ARGS_REGEX).flatten
           @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
@@ -86,7 +86,9 @@ module Liquid
         context.invoke(filter_name, output, *filter_args)
       end
 
-      context.apply_global_filter(obj)
+      obj = context.apply_global_filter(obj)
+      taint_check(context, obj)
+      obj
     end
 
     def render_to_output_buffer(context, output)
@@ -116,14 +118,14 @@ module Liquid
       filter_args  = []
       keyword_args = nil
       unparsed_args.each do |a|
-        if (matches = a.match(JustTagAttributes))
+        if (matches = a.match(JUST_TAG_ATTRIBUTES))
           keyword_args           ||= {}
           keyword_args[matches[1]] = Expression.parse(matches[2])
         else
           filter_args << Expression.parse(a)
         end
       end
-      result = [filter_name.to_sym, filter_args]
+      result = [filter_name, filter_args]
       result << keyword_args if keyword_args
       result
     end
@@ -140,6 +142,25 @@ module Liquid
       parsed_args
     end
 
+    def taint_check(context, obj)
+      return unless obj.tainted?
+      return if Template.taint_mode == :lax
+
+      @markup =~ QUOTED_FRAGMENT
+      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

@@ -12,7 +12,7 @@ module Liquid
     end
 
     def initialize(markup)
-      lookups = markup.scan(VariableParser)
+      lookups = markup.scan(VARIABLE_PARSER)
 
       name = lookups.shift
       if name =~ SQUARE_BRACKETED

liquid.gemspec

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

performance/shopify/comment_form.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 class CommentForm < Liquid::Block
-  Syntax = /(#{Liquid::VariableSignature}+)/
+  SYNTAX = /(#{Liquid::VariableSignature}+)/
 
   def initialize(tag_name, markup, options)
     super
 
-    if markup =~ Syntax
+    if markup =~ SYNTAX
       @variable_name = Regexp.last_match(1)
       @attributes    = {}
     else

performance/shopify/paginate.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 
 class Paginate < Liquid::Block
-  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+  SYNTAX = /(#{Liquid::QUOTED_FRAGMENT})\s*(by\s*(\d+))?/
 
   def initialize(tag_name, markup, options)
     super
 
-    if markup =~ Syntax
+    if markup =~ SYNTAX
       @collection_name = Regexp.last_match(1)
       @page_size       = if Regexp.last_match(2)
         Regexp.last_match(3).to_i
@@ -15,7 +15,7 @@ class Paginate < Liquid::Block
       end
 
       @attributes = { 'window_size' => 3 }
-      markup.scan(Liquid::TagAttributes) do |key, value|
+      markup.scan(Liquid::TAG_ATTRIBUTES) do |key, value|
         @attributes[key] = value
       end
     else

performance/shopify/shop_filter.rb

@@ -60,7 +60,7 @@ module ShopFilter
 
     case style
     when 'original'
-      '/files/shops/random_number/' + url
+      return '/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

test/integration/drop_test.rb

@@ -49,6 +49,10 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
+  def user_input
+    (+"foo").taint
+  end
+
   protected
 
   def callmenot
@@ -110,6 +114,32 @@ class DropsTest < Minitest::Test
     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
+  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))
@@ -249,7 +279,7 @@ class DropsTest < Minitest::Test
   end
 
   def test_invokable_methods
-    assert_equal(%w(to_liquid catchall context texts).to_set, ProductDrop.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)

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) { |node| node.name } # rubocop:disable Style/SymbolProc
+      .add_callback_for(VariableLookup, &:name)
   end
 
   def visit(template)

test/integration/registers/disabled_tags_test.rb

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

test/integration/render_profiling_test.rb

@@ -159,13 +159,13 @@ class RenderProfilingTest < Minitest::Test
     t.render!("collection" => ["one", "two"])
     leaf = t.profiler[0].children[0]
 
-    assert_operator(leaf.self_time, :>, 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)
+    assert_operator t.profiler[0].total_time, :>, 0
   end
 end

test/integration/security_test.rb

@@ -43,22 +43,15 @@ class SecurityTest < Minitest::Test
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: SecurityFilter))
   end
 
-  def test_does_not_permanently_add_filters_to_symbol_table
+  def test_does_not_add_filters_to_symbol_table
     current_symbols = Symbol.all_symbols
 
-    # MRI imprecisely marks objects found on the C stack, which can result
-    # in uninitialized memory being marked. This can even result in the test failing
-    # deterministically for a given compilation of ruby. Using a separate thread will
-    # keep these writes of the symbol pointer on a separate stack that will be garbage
-    # collected after Thread#join.
-    Thread.new do
-      test = %( {{ "some_string" | a_bad_filter }} )
-      Template.parse(test).render!
-      nil
-    end.join
+    test = %( {{ "some_string" | a_bad_filter }} )
 
-    GC.start
+    template = Template.parse(test)
+    assert_equal([], (Symbol.all_symbols - current_symbols))
 
+    template.render!
     assert_equal([], (Symbol.all_symbols - current_symbols))
   end
 

test/integration/standard_filter_test.rb

@@ -768,49 +768,6 @@ class StandardFiltersTest < Minitest::Test
     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
     input = [
       { "foo" => false },

test/integration/tag/disableable_test.rb

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

@@ -60,10 +60,10 @@ class CountingFileSystem
 end
 
 class CustomInclude < Liquid::Tag
-  Syntax = /(#{Liquid::QuotedFragment}+)(\s+(?:with|for)\s+(#{Liquid::QuotedFragment}+))?/o
+  SYNTAX = /(#{Liquid::QUOTED_FRAGMENT}+)(\s+(?:with|for)\s+(#{Liquid::QUOTED_FRAGMENT}+))?/o
 
   def initialize(tag_name, markup, tokens)
-    markup =~ Syntax
+    markup =~ SYNTAX
     @template_name = Regexp.last_match(1)
     super
   end

test/integration/tags/liquid_tag_test.rb

@@ -81,18 +81,6 @@ 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
@@ -103,13 +91,11 @@ class LiquidTagTest < Minitest::Test
   end
 
   def test_quirk_can_close_blocks_created_before_a_liquid_tag
-    assert_usage_increment("liquid_tag_contains_outer_tag") do
-      assert_template_result("42", <<~LIQUID)
-        {%- if true -%}
-        42
-        {%- liquid endif -%}
-      LIQUID
-    end
+    assert_template_result("42", <<~LIQUID)
+      {%- if true -%}
+      42
+      {%- liquid endif -%}
+    LIQUID
   end
 
   def test_liquid_tag_in_raw

test/integration/tags/render_tag_test.rb

@@ -42,6 +42,32 @@ class RenderTagTest < Minitest::Test
     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
+  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 }}")
@@ -127,10 +153,7 @@ class RenderTagTest < Minitest::Test
       'test_include' => '{% include "foo" %}'
     )
 
-    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)
+    assert_template_result('include usage is not allowed in this context', '{% render "test_include" %}')
   end
 
   def test_includes_will_not_render_inside_nested_sibling_tags
@@ -140,8 +163,7 @@ class RenderTagTest < Minitest::Test
       'test_include' => '{% include "foo" %}'
     )
 
-    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)
+    assert_template_result('include usage is not allowed in this contextinclude usage is not allowed in this context', '{% render "nested_render_with_sibling_include" %}')
   end
 
   def test_render_tag_with
@@ -192,22 +214,4 @@ class RenderTagTest < Minitest::Test
     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/test_helper.rb

@@ -54,39 +54,28 @@ module Minitest
       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_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
+      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
 
       globals.each do |global|
         Liquid::Template.register_filter(global)
       end
       yield
     ensure
-      Liquid::StrainerFactory.send(:strainer_class_cache).clear
-      Liquid::StrainerFactory.instance_variable_set(:@global_filters, original_global_filters)
+      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
     end
 
     def with_error_mode(mode)
@@ -98,17 +87,10 @@ module Minitest
     end
 
     def with_custom_tag(tag_name, tag_class)
-      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
+      Liquid::Template.register_tag(tag_name, tag_class)
+      yield
+    ensure
+      Liquid::Template.tags.delete(tag_name)
     end
   end
 end
@@ -154,16 +136,3 @@ 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/context_unit_test.rb

@@ -563,35 +563,6 @@ class ContextUnitTest < Minitest::Test
     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

test/unit/partial_cache_unit_test.rb

@@ -90,39 +90,4 @@ class PartialCacheUnitTest < Minitest::Test
     # but measuring file reads is an OK proxy for this.
     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(QUOTED_FRAGMENT)
   end
 
   def test_quote
-    assert_equal(['"arg 1"'], '"arg 1"'.scan(QuotedFragment))
+    assert_equal ['"arg 1"'], '"arg 1"'.scan(QUOTED_FRAGMENT)
   end
 
   def test_words
-    assert_equal(['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment))
+    assert_equal ['arg1', 'arg2'], 'arg1 arg2'.scan(QUOTED_FRAGMENT)
   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(QUOTED_FRAGMENT)
+    assert_equal ['<tr></tr>'], '<tr></tr>'.scan(QUOTED_FRAGMENT)
+    assert_equal ['<style', 'class="hello">', '</style>'], %(<style class="hello">' </style>).scan(QUOTED_FRAGMENT)
   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(QUOTED_FRAGMENT)
   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(QUOTED_FRAGMENT)
   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(QUOTED_FRAGMENT)
   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(VARIABLE_PARSER)
+    assert_equal ['var', 'method'],                     'var.method'.scan(VARIABLE_PARSER)
+    assert_equal ['var', '[method]'],                   'var[method]'.scan(VARIABLE_PARSER)
+    assert_equal ['var', '[method]', '[0]'],            'var[method][0]'.scan(VARIABLE_PARSER)
+    assert_equal ['var', '["method"]', '[0]'],          'var["method"][0]'.scan(VARIABLE_PARSER)
+    assert_equal ['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VARIABLE_PARSER)
   end
 end # RegexpTest

test/unit/registers/disabled_tags_unit_test.rb

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

test/unit/static_registers_unit_test.rb

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

test/unit/strainer_factory_unit_test.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class StrainerFactoryUnitTest < Minitest::Test
-  include Liquid
-
-  module AccessScopeFilters
-    def public_filter
-      "public"
-    end
-
-    def private_filter
-      "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"))
-  end
-
-  def test_stainer_raises_argument_error
-    strainer = StrainerFactory.create(@context)
-    assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
-    end
-  end
-
-  def test_stainer_argument_error_contains_backtrace
-    strainer = StrainerFactory.create(@context)
-
-    exception = assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
-    end
-
-    assert_match(
-      /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\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"))
-    assert_nil(strainer.invoke("undef_the_filter"))
-  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

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

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

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class TemplateFactoryUnitTest < Minitest::Test
-  include Liquid
-
-  def test_for_returns_liquid_template_instance
-    template = TemplateFactory.new.for("anything")
-    assert_instance_of(Liquid::Template, template)
-  end
-end

test/unit/template_unit_test.rb

@@ -77,11 +77,4 @@ class TemplateUnitTest < Minitest::Test
   ensure
     Template.tags.delete('fake')
   end
-
-  class TemplateSubclass < Liquid::Template
-  end
-
-  def test_template_inheritance
-    assert_equal("foo", TemplateSubclass.parse("foo").render)
-  end
 end

test/unit/variable_unit_test.rb

@@ -13,75 +13,75 @@ class VariableUnitTest < Minitest::Test
   def test_filters
     var = create_variable('hello | textileze')
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:textileze, []]], var.filters)
+    assert_equal([['textileze', []]], var.filters)
 
     var = create_variable('hello | textileze | paragraph')
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:textileze, []], [:paragraph, []]], var.filters)
+    assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable(%( hello | strftime: '%Y'))
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:strftime, ['%Y']]], var.filters)
+    assert_equal([['strftime', ['%Y']]], var.filters)
 
     var = create_variable(%( 'typo' | link_to: 'Typo', true ))
     assert_equal('typo', var.name)
-    assert_equal([[:link_to, ['Typo', true]]], var.filters)
+    assert_equal([['link_to', ['Typo', true]]], var.filters)
 
     var = create_variable(%( 'typo' | link_to: 'Typo', false ))
     assert_equal('typo', var.name)
-    assert_equal([[:link_to, ['Typo', false]]], var.filters)
+    assert_equal([['link_to', ['Typo', false]]], var.filters)
 
     var = create_variable(%( 'foo' | repeat: 3 ))
     assert_equal('foo', var.name)
-    assert_equal([[:repeat, [3]]], var.filters)
+    assert_equal([['repeat', [3]]], var.filters)
 
     var = create_variable(%( 'foo' | repeat: 3, 3 ))
     assert_equal('foo', var.name)
-    assert_equal([[:repeat, [3, 3]]], var.filters)
+    assert_equal([['repeat', [3, 3]]], var.filters)
 
     var = create_variable(%( 'foo' | repeat: 3, 3, 3 ))
     assert_equal('foo', var.name)
-    assert_equal([[:repeat, [3, 3, 3]]], var.filters)
+    assert_equal([['repeat', [3, 3, 3]]], var.filters)
 
     var = create_variable(%( hello | strftime: '%Y, okay?'))
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:strftime, ['%Y, okay?']]], var.filters)
+    assert_equal([['strftime', ['%Y, okay?']]], var.filters)
 
     var = create_variable(%( hello | things: "%Y, okay?", 'the other one'))
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:things, ['%Y, okay?', 'the other one']]], var.filters)
+    assert_equal([['things', ['%Y, okay?', 'the other one']]], var.filters)
   end
 
   def test_filter_with_date_parameter
     var = create_variable(%( '2006-06-06' | date: "%m/%d/%Y"))
     assert_equal('2006-06-06', var.name)
-    assert_equal([[:date, ['%m/%d/%Y']]], var.filters)
+    assert_equal([['date', ['%m/%d/%Y']]], var.filters)
   end
 
   def test_filters_without_whitespace
     var = create_variable('hello | textileze | paragraph')
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:textileze, []], [:paragraph, []]], var.filters)
+    assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable('hello|textileze|paragraph')
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:textileze, []], [:paragraph, []]], var.filters)
+    assert_equal([['textileze', []], ['paragraph', []]], var.filters)
 
     var = create_variable("hello|replace:'foo','bar'|textileze")
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:replace, ['foo', 'bar']], [:textileze, []]], var.filters)
+    assert_equal([['replace', ['foo', 'bar']], ['textileze', []]], var.filters)
   end
 
   def test_symbol
     var = create_variable("http://disney.com/logo.gif | image: 'med' ", error_mode: :lax)
     assert_equal(VariableLookup.new('http://disney.com/logo.gif'), var.name)
-    assert_equal([[:image, ['med']]], var.filters)
+    assert_equal([['image', ['med']]], var.filters)
   end
 
   def test_string_to_filter
     var = create_variable("'http://disney.com/logo.gif' | image: 'med' ")
     assert_equal('http://disney.com/logo.gif', var.name)
-    assert_equal([[:image, ['med']]], var.filters)
+    assert_equal([['image', ['med']]], var.filters)
   end
 
   def test_string_single_quoted
@@ -128,13 +128,13 @@ class VariableUnitTest < Minitest::Test
   def test_filter_with_keyword_arguments
     var = create_variable(%( hello | things: greeting: "world", farewell: 'goodbye'))
     assert_equal(VariableLookup.new('hello'), var.name)
-    assert_equal([[:things, [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters)
+    assert_equal([['things', [], { 'greeting' => 'world', 'farewell' => 'goodbye' }]], var.filters)
   end
 
   def test_lax_filter_argument_parsing
     var = create_variable(%( number_of_comments | pluralize: 'comment': 'comments' ), error_mode: :lax)
     assert_equal(VariableLookup.new('number_of_comments'), var.name)
-    assert_equal([[:pluralize, ['comment', 'comments']]], var.filters)
+    assert_equal([['pluralize', ['comment', 'comments']]], var.filters)
   end
 
   def test_strict_filter_argument_parsing