Improve error message of Liquid::MemoryLimit.

The existing error message is too generic since there are three types of limits in place.
It is useful to know which limit was reached to make it easier to debug the error.

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

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

.rubocop_todo.yml

@@ -18,9 +18,28 @@ Lint/InheritException:
 # Cop supports --auto-correct.
 # Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
-Metrics/LineLength:
+Layout/LineLength:
   Max: 294
 
+# Offense count: 44
+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
-  - &latest_ruby 2.6
-  - 2.7
+  - 2.6
+  - &latest_ruby 2.7
   - ruby-head
 
 matrix:
@@ -13,8 +13,6 @@ matrix:
     - rvm: *latest_ruby
       script: bundle exec rake memory_profile:run
       name: Profiling Memory Usage
-  allow_failures:
-    - rvm: ruby-head
 
 branches:
   only:

Gemfile

@@ -18,7 +18,7 @@ group :benchmark, :test do
 end
 
 group :test do
-  gem 'rubocop', '~> 0.74.0', require: false
+  gem 'rubocop', '~> 0.78.0', require: false
   gem 'rubocop-performance', require: false
 
   platform :mri, :truffleruby do

History.md

@@ -1,5 +1,11 @@
 # Liquid Change Log
 
+### Unreleased
+
+* Split Strainer class as a factory and a template (#1208) [Thierry Joyal]
+* Remove handling of a nil context in the Strainer class (#1218) [Thierry Joyal]
+* Change `Liquid::MemoryError` message to be more specific about which limit was reached. (#1206) [Alan Tan]
+
 ## 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
-  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
+  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
 
   singleton_class.send(:attr_accessor, :cache_classes)
   self.cache_classes = true
@@ -57,7 +57,8 @@ require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer'
+require 'liquid/strainer_factory'
+require 'liquid/strainer_template'
 require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/parser_switching'
@@ -80,10 +81,9 @@ 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,13 +1,15 @@
 # frozen_string_literal: true
 
+require 'English'
+
 module Liquid
   class BlockBody
-    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      = "{{"
+    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            = "{{"
 
     attr_reader :nodelist
 
@@ -28,8 +30,8 @@ module Liquid
 
     private def parse_for_liquid_tag(tokenizer, parse_context)
       while (token = tokenizer.shift)
-        unless token.empty? || token =~ WHITESPACE_OR_NOTHING
-          unless token =~ LIQUID_TAG_TOKEN
+        unless token.empty? || token =~ WhitespaceOrNothing
+          unless token =~ LiquidTagToken
             # line isn't empty but didn't match tag syntax, yield and let the
             # caller raise a syntax error
             return yield token, token
@@ -51,13 +53,28 @@ 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?(TAG_START_STRING)
+        when token.start_with?(TAGSTART)
           whitespace_handler(token, parse_context)
-          unless token =~ FULL_TOKEN
+          unless token =~ FullToken
             raise_missing_tag_terminator(token, parse_context)
           end
           tag_name = Regexp.last_match(2)
@@ -70,8 +87,8 @@ module Liquid
           end
 
           if tag_name == 'liquid'
-            liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
-            next parse_for_liquid_tag(liquid_tag_tokenizer, parse_context, &block)
+            parse_liquid_tag(markup, parse_context, &block)
+            next
           end
 
           unless (tag = registered_tags[tag_name])
@@ -82,7 +99,7 @@ module Liquid
           new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
           @blank &&= new_tag.blank?
           @nodelist << new_tag
-        when token.start_with?(VAR_START_STRING)
+        when token.start_with?(VARSTART)
           whitespace_handler(token, parse_context)
           @nodelist << create_variable(token, parse_context)
           @blank = false
@@ -92,7 +109,7 @@ module Liquid
           end
           parse_context.trim_whitespace = false
           @nodelist << token
-          @blank &&= !!(token =~ WHITESPACE_OR_NOTHING)
+          @blank &&= !!(token =~ WhitespaceOrNothing)
         end
         parse_context.line_number = tokenizer.line_number
       end
@@ -101,13 +118,13 @@ module Liquid
     end
 
     def whitespace_handler(token, parse_context)
-      if token[2] == WHITESPACE_CONTROL
+      if token[2] == WhitespaceControl
         previous_token = @nodelist.last
         if previous_token.is_a?(String)
           previous_token.rstrip!
         end
       end
-      parse_context.trim_whitespace = (token[-3] == WHITESPACE_CONTROL)
+      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
     end
 
     def blank?
@@ -175,12 +192,22 @@ module Liquid
 
     def raise_if_resource_limits_reached(context, length)
       context.resource_limits.render_length += length
-      return unless context.resource_limits.reached?
-      raise MemoryError, "Memory limits exceeded"
+
+      error_message =
+        if context.resource_limits.render_length_reached?
+          MemoryError::RENDER_LENGTH_ERROR_MESSAGE
+        elsif context.resource_limits.render_score_reached?
+          MemoryError::RENDER_SCORE_ERROR_MESSAGE
+        elsif context.resource_limits.assign_score_reached?
+          MemoryError::ASSIGN_SCORE_ERROR_MESSAGE
+        end
+
+      return unless error_message
+      raise MemoryError, error_message
     end
 
     def create_variable(token, parse_context)
-      token.scan(CONTENT_OF_VARIABLE) do |content|
+      token.scan(ContentOfVariable) do |content|
         markup = content.first
         return Variable.new(markup, parse_context)
       end
@@ -188,11 +215,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: TAG_END.inspect)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
     end
 
     def raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VARIABLE_END.inspect)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
     end
 
     def registered_tags

lib/liquid/context.rb

@@ -52,7 +52,7 @@ module Liquid
     end
 
     def strainer
-      @strainer ||= Strainer.create(self, @filters)
+      @strainer ||= StrainerFactory.create(self, @filters)
     end
 
     # Adds filters to this context.

lib/liquid/errors.rb

@@ -23,11 +23,14 @@ module Liquid
 
     def message_prefix
       str = +""
-      str << if is_a?(SyntaxError)
-        "Liquid syntax error"
-      else
-        "Liquid error"
-      end
+      str <<
+        if is_a?(SyntaxError)
+          "Liquid syntax error"
+        elsif is_a?(MemoryError)
+          "Liquid memory limit error"
+        else
+          "Liquid error"
+        end
 
       if line_number
         str << " ("
@@ -40,6 +43,12 @@ module Liquid
     end
   end
 
+  class MemoryError < Error
+    RENDER_LENGTH_ERROR_MESSAGE = 'Too many bytes rendered.'
+    RENDER_SCORE_ERROR_MESSAGE = 'Too many tags rendered.'
+    ASSIGN_SCORE_ERROR_MESSAGE = 'Too many bytes assigned to variables.'
+  end
+
   ArgumentError       = Class.new(Error)
   ContextError        = Class.new(Error)
   FileSystemError     = Class.new(Error)
@@ -47,7 +56,6 @@ module Liquid
   SyntaxError         = Class.new(Error)
   StackLevelError     = Class.new(Error)
   TaintedError        = Class.new(Error)
-  MemoryError         = Class.new(Error)
   ZeroDivisionError   = Class.new(Error)
   FloatDomainError    = Class.new(Error)
   UndefinedVariable   = Class.new(Error)

lib/liquid/legacy.rb

@@ -1,79 +0,0 @@
-# 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
-          return strict_parse_with_error_context(markup)
+          strict_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
-          return lax_parse(markup)
+          lax_parse(markup)
         end
       end
     end

lib/liquid/partial_cache.rb

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

lib/liquid/resource_limits.rb

@@ -12,10 +12,16 @@ module Liquid
       reset
     end
 
-    def reached?
-      (@render_length_limit && @render_length > @render_length_limit) ||
-        (@render_score_limit && @render_score > @render_score_limit) ||
-        (@assign_score_limit && @assign_score > @assign_score_limit)
+    def render_length_reached?
+      @render_length_limit && @render_length > @render_length_limit
+    end
+
+    def render_score_reached?
+      @render_score_limit && @render_score > @render_score_limit
+    end
+
+    def assign_score_reached?
+      @assign_score_limit && @assign_score > @assign_score_limit
     end
 
     def reset

lib/liquid/strainer.rb

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

lib/liquid/strainer_factory.rb

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

lib/liquid/strainer_template.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Liquid
+  # StrainerTemplate is the computed class for the filters system.
+  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
+  #
+  # The Strainer only allows method calls defined in filters given to it via StrainerFactory.add_global_filter,
+  # Context#add_filters or Template.register_filter
+  class StrainerTemplate
+    def initialize(context)
+      @context = context
+    end
+
+    class << self
+      def add_filter(filter)
+        return if include?(filter)
+
+        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
+        if invokable_non_public_methods.any?
+          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
+        end
+
+        include(filter)
+
+        filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+      end
+
+      def invokable?(method)
+        filter_methods.include?(method.to_s)
+      end
+
+      private
+
+      def filter_methods
+        @filter_methods ||= Set.new
+      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/tags/assign.rb

@@ -10,7 +10,7 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    SYNTAX = /(#{VARIABLE_SIGNATURE}+)\s*=\s*(.*)\s*/om
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
     def self.syntax_error_translation_key
       "errors.syntax.assign"
@@ -20,8 +20,8 @@ module Liquid
 
     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(self.class.syntax_error_translation_key)

lib/liquid/tags/capture.rb

@@ -13,11 +13,11 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    SYNTAX = /(#{VARIABLE_SIGNATURE}+)/o
+    Syntax = /(#{VariableSignature}+)/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 = /(#{QUOTED_FRAGMENT})/o
-    WHEN_SYNTAX = /(#{QUOTED_FRAGMENT})(?:(?:\s+or\s+|\s*\,\s*)(#{QUOTED_FRAGMENT}.*))?/om
+    Syntax     = /(#{QuotedFragment})/o
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/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 =~ WHEN_SYNTAX
+        unless markup =~ WhenSyntax
           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
-    SIMPLE_SYNTAX = /\A#{QUOTED_FRAGMENT}+/o
-    NAMED_SYNTAX  = /\A(#{QUOTED_FRAGMENT})\s*\:\s*(.*)/om
+    SimpleSyntax = /\A#{QuotedFragment}+/o
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
 
     attr_reader :variables
 
     def initialize(tag_name, markup, options)
       super
       case markup
-      when NAMED_SYNTAX
+      when NamedSyntax
         @variables = variables_from_string(Regexp.last_match(2))
         @name      = Expression.parse(Regexp.last_match(1))
-      when SIMPLE_SYNTAX
+      when SimpleSyntax
         @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*(#{QUOTED_FRAGMENT})\s*/o
+        var =~ /\s*(#{QuotedFragment})\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(#{VARIABLE_SEGMENT}+)\s+in\s+(#{QUOTED_FRAGMENT}+)\s*(reversed)?/o
+    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\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(TAG_ATTRIBUTES) do |key, value|
+        markup.scan(TagAttributes) 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                    = /(#{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
+    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
 
     attr_reader :blocks
 
@@ -65,15 +65,15 @@ module Liquid
     end
 
     def lax_parse(markup)
-      expressions = markup.scan(EXPRESSIONS_AND_OPERATORS)
-      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ SYNTAX
+      expressions = markup.scan(ExpressionsAndOperators)
+      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

@@ -17,6 +17,7 @@ module Liquid
   #
   class Include < Tag
     SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    Syntax = SYNTAX
 
     attr_reader :template_name_expr, :variable_name_expr, :attributes
 
@@ -33,7 +34,7 @@ module Liquid
         @template_name_expr = Expression.parse(template_name)
         @attributes         = {}
 
-        markup.scan(TAG_ATTRIBUTES) do |key, value|
+        markup.scan(TagAttributes) 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/
-    FULL_TOKEN_POSSIBLY_INVALID = /\A(.*)#{TAG_START}\s*(\w+)\s*(.*)?#{TAG_END}\z/om
+    Syntax = /\A\s*\z/
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\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 =~ FULL_TOKEN_POSSIBLY_INVALID
+        if token =~ FullTokenPossiblyInvalid
           @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,7 +2,8 @@
 
 module Liquid
   class Render < Tag
-    SYNTAX = /(#{QuotedString}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    FOR = 'for'
+    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
 
     disable_tags "include"
 
@@ -14,14 +15,16 @@ module Liquid
       raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
 
       template_name = Regexp.last_match(1)
-      variable_name = Regexp.last_match(3)
+      with_or_for = Regexp.last_match(3)
+      variable_name = Regexp.last_match(4)
 
-      @alias_name = Regexp.last_match(5)
+      @alias_name = Regexp.last_match(6)
       @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
       @template_name_expr = Expression.parse(template_name)
+      @for = (with_or_for == FOR)
 
       @attributes = {}
-      markup.scan(TAG_ATTRIBUTES) do |key, value|
+      markup.scan(TagAttributes) do |key, value|
         @attributes[key] = Expression.parse(value)
       end
     end
@@ -58,7 +61,7 @@ module Liquid
       }
 
       variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
-      if variable.is_a?(Array)
+      if @for && variable.respond_to?(:each) && variable.respond_to?(:count)
         forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
         variable.each { |var| render_partial_func.call(var, forloop) }
       else

lib/liquid/tags/table_row.rb

@@ -2,17 +2,17 @@
 
 module Liquid
   class TableRow < Block
-    SYNTAX = /(\w+)\s+in\s+(#{QUOTED_FRAGMENT}+)/o
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/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(TAG_ATTRIBUTES) do |key, value|
+        markup.scan(TagAttributes) do |key, value|
           @attributes[key] = Expression.parse(value)
         end
       else

lib/liquid/template.rb

@@ -18,8 +18,6 @@ module Liquid
     attr_accessor :root
     attr_reader :resource_limits, :warnings
 
-    @@file_system = BlankFileSystem.new
-
     class TagRegistry
       include Enumerable
 
@@ -63,60 +61,59 @@ module Liquid
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
       # :warn is the default and will give deprecation warnings when invalid syntax is used.
       # :strict will enforce correct syntax.
-      attr_writer :error_mode
+      attr_accessor :error_mode
+      Template.error_mode = :lax
+
+      attr_reader :taint_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
+      # @deprecated Since it is being deprecated in ruby itself.
+      def taint_mode=(mode)
+        taint_supported = Object.new.taint.tainted?
+        if mode != :lax && !taint_supported
+          raise NotImplementedError, "#{RUBY_ENGINE} #{RUBY_VERSION} doesn't support taint checking"
+        end
+        @taint_mode = mode
+      end
+
+      Template.taint_mode = :lax
 
       attr_accessor :default_exception_renderer
       Template.default_exception_renderer = lambda do |exception|
         exception
       end
 
-      def file_system
-        @@file_system
-      end
+      attr_accessor :file_system
+      Template.file_system = BlankFileSystem.new
 
-      def file_system=(obj)
-        @@file_system = obj
-      end
+      attr_accessor :tags
+      Template.tags = TagRegistry.new
+      private :tags=
 
       def register_tag(name, klass)
         tags[name.to_s] = klass
       end
 
-      def tags
-        @tags ||= TagRegistry.new
-      end
+      attr_accessor :registers
+      Template.registers = {}
+      private :registers=
 
       def add_register(name, klass)
         registers[name.to_sym] = klass
       end
 
-      def registers
-        @registers ||= {}
-      end
-
-      def error_mode
-        @error_mode ||= :lax
-      end
-
-      def taint_mode
-        @taint_mode ||= :lax
-      end
-
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
-        Strainer.global_filter(mod)
+        StrainerFactory.add_global_filter(mod)
       end
 
-      def default_resource_limits
-        @default_resource_limits ||= {}
-      end
+      attr_accessor :default_resource_limits
+      Template.default_resource_limits = {}
+      private :default_resource_limits=
 
       # creates a new <tt>Template</tt> object from liquid source code
       # To enable profiling, pass in <tt>profile: true</tt> as an option.

lib/liquid/template_factory.rb

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

lib/liquid/tokenizer.rb

@@ -28,7 +28,7 @@ module Liquid
 
       return @source.split("\n") if @for_liquid_tag
 
-      tokens = @source.split(TEMPLATE_PARSER)
+      tokens = @source.split(TemplateParser)
 
       # 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
-    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
+    FilterMarkupRegex        = /#{FilterSeparator}\s*(.*)/om
+    FilterParser             = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterArgsRegex          = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
+    JustTagAttributes        = /\A#{TagAttributes}\z/o
+    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
 
     attr_accessor :filters, :name, :line_number
     attr_reader :parse_context
@@ -43,17 +43,17 @@ module Liquid
 
     def lax_parse(markup)
       @filters = []
-      return unless markup =~ MARKUP_WITH_QUOTED_FRAGMENT
+      return unless markup =~ MarkupWithQuotedFragment
 
       name_markup   = Regexp.last_match(1)
       filter_markup = Regexp.last_match(2)
       @name         = Expression.parse(name_markup)
-      if filter_markup =~ FILTER_MARKUP_REGEX
-        filters = Regexp.last_match(1).scan(FILTER_PARSER)
+      if filter_markup =~ FilterMarkupRegex
+        filters = Regexp.last_match(1).scan(FilterParser)
         filters.each do |f|
           next unless f =~ /\w+/
           filtername = Regexp.last_match(0)
-          filterargs = f.scan(FILTER_ARGS_REGEX).flatten
+          filterargs = f.scan(FilterArgsRegex).flatten
           @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
@@ -118,7 +118,7 @@ module Liquid
       filter_args  = []
       keyword_args = nil
       unparsed_args.each do |a|
-        if (matches = a.match(JUST_TAG_ATTRIBUTES))
+        if (matches = a.match(JustTagAttributes))
           keyword_args           ||= {}
           keyword_args[matches[1]] = Expression.parse(matches[2])
         else
@@ -143,10 +143,10 @@ module Liquid
     end
 
     def taint_check(context, obj)
-      return unless obj.tainted?
       return if Template.taint_mode == :lax
+      return unless obj.tainted?
 
-      @markup =~ QUOTED_FRAGMENT
+      @markup =~ QuotedFragment
       name = Regexp.last_match(0)
 
       error               = TaintedError.new("variable '#{name}' is tainted and was not escaped")

lib/liquid/variable_lookup.rb

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

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::QUOTED_FRAGMENT})\s*(by\s*(\d+))?/
+  Syntax = /(#{Liquid::QuotedFragment})\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::TAG_ATTRIBUTES) do |key, value|
+      markup.scan(Liquid::TagAttributes) do |key, value|
         @attributes[key] = value
       end
     else

performance/shopify/shop_filter.rb

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

test/integration/drop_test.rb

@@ -114,29 +114,31 @@ 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)
+  if taint_supported?
+    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
-  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)
+    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
-  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)
+    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
   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/standard_filter_test.rb

@@ -768,6 +768,49 @@ 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/tags/include_tag_test.rb

@@ -60,10 +60,10 @@ class CountingFileSystem
 end
 
 class CustomInclude < Liquid::Tag
-  SYNTAX = /(#{Liquid::QUOTED_FRAGMENT}+)(\s+(?:with|for)\s+(#{Liquid::QUOTED_FRAGMENT}+))?/o
+  Syntax = /(#{Liquid::QuotedFragment}+)(\s+(?:with|for)\s+(#{Liquid::QuotedFragment}+))?/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,6 +81,18 @@ class LiquidTagTest < Minitest::Test
     assert_match_syntax_error("syntax error (line 3): Unknown tag 'error'", "{% liquid echo ''\n  \n error %}")
   end
 
+  def test_nested_liquid_tag
+    assert_usage_increment("liquid_tag_contains_outer_tag", times: 0) do
+      assert_template_result('good', <<~LIQUID)
+        {%- if true %}
+          {%- liquid
+            echo "good"
+          %}
+        {%- endif -%}
+      LIQUID
+    end
+  end
+
   def test_cannot_open_blocks_living_past_a_liquid_tag
     assert_match_syntax_error("syntax error (line 3): 'if' tag was never closed", <<~LIQUID)
       {%- liquid
@@ -91,11 +103,13 @@ class LiquidTagTest < Minitest::Test
   end
 
   def test_quirk_can_close_blocks_created_before_a_liquid_tag
-    assert_template_result("42", <<~LIQUID)
-      {%- if true -%}
-      42
-      {%- liquid endif -%}
-    LIQUID
+    assert_usage_increment("liquid_tag_contains_outer_tag") do
+      assert_template_result("42", <<~LIQUID)
+        {%- if true -%}
+        42
+        {%- liquid endif -%}
+      LIQUID
+    end
   end
 
   def test_liquid_tag_in_raw

test/integration/tags/render_tag_test.rb

@@ -42,29 +42,31 @@ 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 }}')
+  if taint_supported?
+    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)
+      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
+        assert_equal [Liquid::TaintedError], template.errors.map(&:class)
+        assert_equal 'snippet', template.errors.first.template_name
+      end
     end
-  end
 
-  def test_render_sets_the_correct_template_name_for_warnings
-    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
+    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)
+      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
+        assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+        assert_equal 'snippet', context.warnings.first.template_name
+      end
     end
   end
 
@@ -214,4 +216,22 @@ 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/integration/template_test.rb

@@ -112,8 +112,8 @@ class TemplateTest < Minitest::Test
   def test_resource_limits_render_length
     t = Template.parse("0123456789")
     t.resource_limits.render_length_limit = 5
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.render_length_reached?)
 
     t.resource_limits.render_length_limit = 10
     assert_equal("0123456789", t.render!)
@@ -123,13 +123,13 @@ class TemplateTest < Minitest::Test
   def test_resource_limits_render_score
     t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.render_score_reached?)
 
     t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.render_score_reached?)
 
     t.resource_limits.render_score_limit = 200
     assert_equal((" foo " * 100), t.render!)
@@ -139,8 +139,8 @@ class TemplateTest < Minitest::Test
   def test_resource_limits_assign_score
     t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
     t.resource_limits.assign_score_limit = 1
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::ASSIGN_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.assign_score_reached?)
 
     t.resource_limits.assign_score_limit = 2
     assert_equal("", t.render!)
@@ -161,8 +161,8 @@ class TemplateTest < Minitest::Test
     t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
 
     t.resource_limits.assign_score_limit = 3
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::ASSIGN_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.assign_score_reached?)
 
     t.resource_limits.assign_score_limit = 5
     assert_equal("", t.render!)
@@ -171,8 +171,8 @@ class TemplateTest < Minitest::Test
   def test_resource_limits_aborts_rendering_after_first_error
     t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
-    assert(t.resource_limits.reached?)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
+    assert(t.resource_limits.render_score_reached?)
   end
 
   def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
@@ -186,21 +186,21 @@ class TemplateTest < Minitest::Test
   def test_render_length_persists_between_blocks
     t = Template.parse("{% if true %}aaaa{% endif %}")
     t.resource_limits.render_length_limit = 7
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
     t.resource_limits.render_length_limit = 8
     assert_equal("aaaa", t.render)
 
     t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
     t.resource_limits.render_length_limit = 13
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
     t.resource_limits.render_length_limit = 14
     assert_equal("aaaabbb", t.render)
 
     t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
     t.resource_limits.render_length_limit = 5
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
     t.resource_limits.render_length_limit = 11
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
     t.resource_limits.render_length_limit = 12
     assert_equal("ababab", t.render)
   end
@@ -208,7 +208,7 @@ class TemplateTest < Minitest::Test
   def test_render_length_uses_number_of_bytes_not_characters
     t = Template.parse("{% if true %}すごい{% endif %}")
     t.resource_limits.render_length_limit = 10
-    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
     t.resource_limits.render_length_limit = 18
     assert_equal("すごい", t.render)
   end
@@ -361,4 +361,12 @@ class TemplateTest < Minitest::Test
     result = t.render('x' => 1, 'y' => 5)
     assert_equal('12345', result)
   end
+
+  unless taint_supported?
+    def test_taint_mode
+      assert_raises(NotImplementedError) do
+        Template.taint_mode = :warn
+      end
+    end
+  end
 end

test/test_helper.rb

@@ -32,6 +32,10 @@ module Minitest
     def fixture(name)
       File.join(File.expand_path(__dir__), "fixtures", name)
     end
+
+    def self.taint_supported?
+      Object.new.taint.tainted?
+    end
   end
 
   module Assertions
@@ -54,20 +58,39 @@ 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_strainer = Liquid::Strainer.class_variable_get(:@@global_strainer)
-      Liquid::Strainer.class_variable_set(:@@global_strainer, Class.new(Liquid::Strainer) do
-        @filter_methods = Set.new
-      end)
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
+      original_global_filters = Liquid::StrainerFactory.instance_variable_get(:@global_filters)
+      Liquid::StrainerFactory.instance_variable_set(:@global_filters, [])
+      globals.each do |global|
+        Liquid::StrainerFactory.add_global_filter(global)
+      end
+
+      Liquid::StrainerFactory.send(:strainer_class_cache).clear
 
       globals.each do |global|
         Liquid::Template.register_filter(global)
       end
       yield
     ensure
-      Liquid::Strainer.class_variable_get(:@@strainer_class_cache).clear
-      Liquid::Strainer.class_variable_set(:@@global_strainer, original_global_strainer)
+      Liquid::StrainerFactory.send(:strainer_class_cache).clear
+      Liquid::StrainerFactory.instance_variable_set(:@global_filters, original_global_filters)
     end
 
     def with_taint_mode(mode)
@@ -136,3 +159,16 @@ class StubFileSystem
     @values.fetch(template_path)
   end
 end
+
+class StubTemplateFactory
+  attr_reader :count
+
+  def initialize
+    @count = 0
+  end
+
+  def for(_template_name)
+    @count += 1
+    Liquid::Template.new
+  end
+end

test/unit/partial_cache_unit_test.rb

@@ -90,4 +90,39 @@ 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(QUOTED_FRAGMENT)
+    assert_equal([], ''.scan(QuotedFragment))
   end
 
   def test_quote
-    assert_equal ['"arg 1"'], '"arg 1"'.scan(QUOTED_FRAGMENT)
+    assert_equal(['"arg 1"'], '"arg 1"'.scan(QuotedFragment))
   end
 
   def test_words
-    assert_equal ['arg1', 'arg2'], 'arg1 arg2'.scan(QUOTED_FRAGMENT)
+    assert_equal(['arg1', 'arg2'], 'arg1 arg2'.scan(QuotedFragment))
   end
 
   def test_tags
-    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)
+    assert_equal(['<tr>', '</tr>'], '<tr> </tr>'.scan(QuotedFragment))
+    assert_equal(['<tr></tr>'], '<tr></tr>'.scan(QuotedFragment))
+    assert_equal(['<style', 'class="hello">', '</style>'], %(<style class="hello">' </style>).scan(QuotedFragment))
   end
 
   def test_double_quoted_words
-    assert_equal ['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QUOTED_FRAGMENT)
+    assert_equal(['arg1', 'arg2', '"arg 3"'], 'arg1 arg2 "arg 3"'.scan(QuotedFragment))
   end
 
   def test_single_quoted_words
-    assert_equal ['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QUOTED_FRAGMENT)
+    assert_equal(['arg1', 'arg2', "'arg 3'"], 'arg1 arg2 \'arg 3\''.scan(QuotedFragment))
   end
 
   def test_quoted_words_in_the_middle
-    assert_equal ['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4   '.scan(QUOTED_FRAGMENT)
+    assert_equal(['arg1', 'arg2', '"arg 3"', 'arg4'], 'arg1 arg2 "arg 3" arg4   '.scan(QuotedFragment))
   end
 
   def test_variable_parser
-    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)
+    assert_equal(['var'],                               'var'.scan(VariableParser))
+    assert_equal(['var', 'method'],                     'var.method'.scan(VariableParser))
+    assert_equal(['var', '[method]'],                   'var[method]'.scan(VariableParser))
+    assert_equal(['var', '[method]', '[0]'],            'var[method][0]'.scan(VariableParser))
+    assert_equal(['var', '["method"]', '[0]'],          'var["method"][0]'.scan(VariableParser))
+    assert_equal(['var', '[method]', '[0]', 'method'],  'var[method][0].method'.scan(VariableParser))
   end
 end # RegexpTest

test/unit/strainer_factory_unit_test.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class StrainerFactoryUnitTest < Minitest::Test
+  include Liquid
+
+  module AccessScopeFilters
+    def public_filter
+      "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

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

test/unit/strainer_unit_test.rb

@@ -1,167 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class StrainerUnitTest < Minitest::Test
-  include Liquid
-
-  module AccessScopeFilters
-    def public_filter
-      "public"
-    end
-
-    def private_filter
-      "private"
-    end
-    private :private_filter
-  end
-
-  Strainer.global_filter(AccessScopeFilters)
-
-  def test_strainer
-    strainer = Strainer.create(nil)
-    assert_equal(5, strainer.invoke('size', 'input'))
-    assert_equal("public", strainer.invoke("public_filter"))
-  end
-
-  def test_stainer_raises_argument_error
-    strainer = Strainer.create(nil)
-    assert_raises(Liquid::ArgumentError) do
-      strainer.invoke("public_filter", 1)
-    end
-  end
-
-  def test_stainer_argument_error_contains_backtrace
-    strainer = Strainer.create(nil)
-    begin
-      strainer.invoke("public_filter", 1)
-    rescue Liquid::ArgumentError => e
-      assert_match(
-        /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/,
-        e.message
-      )
-      assert_equal(e.backtrace[0].split(':')[0], __FILE__)
-    end
-  end
-
-  def test_strainer_only_invokes_public_filter_methods
-    strainer = Strainer.create(nil)
-    assert_equal(false, strainer.class.invokable?('__test__'))
-    assert_equal(false, strainer.class.invokable?('test'))
-    assert_equal(false, strainer.class.invokable?('instance_eval'))
-    assert_equal(false, strainer.class.invokable?('__send__'))
-    assert_equal(true, strainer.class.invokable?('size')) # from the standard lib
-  end
-
-  def test_strainer_returns_nil_if_no_filter_method_found
-    strainer = Strainer.create(nil)
-    assert_nil(strainer.invoke("private_filter"))
-    assert_nil(strainer.invoke("undef_the_filter"))
-  end
-
-  def test_strainer_returns_first_argument_if_no_method_and_arguments_given
-    strainer = Strainer.create(nil)
-    assert_equal("password", strainer.invoke("undef_the_method", "password"))
-  end
-
-  def test_strainer_only_allows_methods_defined_in_filters
-    strainer = Strainer.create(nil)
-    assert_equal("1 + 1", strainer.invoke("instance_eval", "1 + 1"))
-    assert_equal("puts",  strainer.invoke("__send__", "puts", "Hi Mom"))
-    assert_equal("has_method?", strainer.invoke("invoke", "has_method?", "invoke"))
-  end
-
-  def test_strainer_uses_a_class_cache_to_avoid_method_cache_invalidation
-    a = Module.new
-    b = Module.new
-    strainer = Strainer.create(nil, [a, b])
-    assert_kind_of(Strainer, strainer)
-    assert_kind_of(a, strainer)
-    assert_kind_of(b, strainer)
-    assert_kind_of(Liquid::StandardFilters, strainer)
-  end
-
-  def test_add_filter_when_wrong_filter_class
-    c = Context.new
-    s = c.strainer
-    wrong_filter = ->(v) { v.reverse }
-
-    assert_raises ArgumentError do
-      s.class.add_filter(wrong_filter)
-    end
-  end
-
-  module PrivateMethodOverrideFilter
-    private
-
-    def public_filter
-      "overriden as private"
-    end
-  end
-
-  def test_add_filter_raises_when_module_privately_overrides_registered_public_methods
-    strainer = Context.new.strainer
-
-    error = assert_raises(Liquid::MethodOverrideError) do
-      strainer.class.add_filter(PrivateMethodOverrideFilter)
-    end
-    assert_equal('Liquid error: Filter overrides registered public methods as non public: public_filter', error.message)
-  end
-
-  module ProtectedMethodOverrideFilter
-    protected
-
-    def public_filter
-      "overriden as protected"
-    end
-  end
-
-  def test_add_filter_raises_when_module_overrides_registered_public_method_as_protected
-    strainer = Context.new.strainer
-
-    error = assert_raises(Liquid::MethodOverrideError) do
-      strainer.class.add_filter(ProtectedMethodOverrideFilter)
-    end
-    assert_equal('Liquid error: Filter overrides registered public methods as non public: public_filter', error.message)
-  end
-
-  module PublicMethodOverrideFilter
-    def public_filter
-      "public"
-    end
-  end
-
-  def test_add_filter_does_not_raise_when_module_overrides_previously_registered_method
-    strainer = Context.new.strainer
-    strainer.class.add_filter(PublicMethodOverrideFilter)
-    assert(strainer.class.filter_methods.include?('public_filter'))
-  end
-
-  module LateAddedFilter
-    def late_added_filter(_input)
-      "filtered"
-    end
-  end
-
-  def test_global_filter_clears_cache
-    assert_equal('input', Strainer.create(nil).invoke('late_added_filter', 'input'))
-    Strainer.global_filter(LateAddedFilter)
-    assert_equal('filtered', Strainer.create(nil).invoke('late_added_filter', 'input'))
-  end
-
-  def test_add_filter_does_not_include_already_included_module
-    mod = Module.new do
-      class << self
-        attr_accessor :include_count
-        def included(_mod)
-          self.include_count += 1
-        end
-      end
-      self.include_count = 0
-    end
-    strainer = Context.new.strainer
-    strainer.class.add_filter(mod)
-    strainer.class.add_filter(mod)
-    assert_equal(1, mod.include_count)
-  end
-end # StrainerTest

test/unit/template_factory_unit_test.rb

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