Fix post-trim for the raw tag

The added test did not pass before this commit.

.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,7 +18,7 @@ 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

.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:
@@ -13,6 +13,8 @@ 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.78.0', require: false
+  gem 'rubocop', '~> 0.74.0', require: false
   gem 'rubocop-performance', require: false
 
   platform :mri, :truffleruby do

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

@@ -57,8 +57,7 @@ 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'
@@ -81,7 +80,6 @@ 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
 #

lib/liquid/block_body.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'English'
-
 module Liquid
   class BlockBody
     LiquidTagToken      = /\A\s*(\w+)\s*(.*?)\z/o
@@ -53,21 +51,6 @@ 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?
@@ -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])
@@ -192,18 +175,8 @@ module Liquid
 
     def raise_if_resource_limits_reached(context, length)
       context.resource_limits.render_length += length
-
-      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
+      return unless context.resource_limits.reached?
+      raise MemoryError, "Memory limits exceeded"
     end
 
     def create_variable(token, parse_context)

lib/liquid/context.rb

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

lib/liquid/errors.rb

@@ -23,14 +23,11 @@ module Liquid
 
     def message_prefix
       str = +""
-      str <<
-        if is_a?(SyntaxError)
-          "Liquid syntax error"
-        elsif is_a?(MemoryError)
-          "Liquid memory limit error"
-        else
-          "Liquid error"
-        end
+      str << if is_a?(SyntaxError)
+        "Liquid syntax error"
+      else
+        "Liquid error"
+      end
 
       if line_number
         str << " ("
@@ -43,12 +40,6 @@ 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)
@@ -56,6 +47,7 @@ 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/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/resource_limits.rb

@@ -12,16 +12,10 @@ module Liquid
       reset
     end
 
-    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
+    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)
     end
 
     def reset

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_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/raw.rb

@@ -16,7 +16,10 @@ module Liquid
       while (token = tokens.shift)
         if token =~ FullTokenPossiblyInvalid
           @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
-          return if block_delimiter == Regexp.last_match(2)
+          if block_delimiter == Regexp.last_match(2)
+            @parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
+            return
+          end
         end
         @body << token unless token.empty?
       end

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,59 +63,60 @@ 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_reader :taint_mode
+      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
-      # @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_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
 
-      attr_accessor :registers
-      Template.registers = {}
-      private :registers=
+      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.

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

@@ -143,8 +143,8 @@ module Liquid
     end
 
     def taint_check(context, obj)
-      return if Template.taint_mode == :lax
       return unless obj.tainted?
+      return if Template.taint_mode == :lax
 
       @markup =~ QuotedFragment
       name = Regexp.last_match(0)

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

@@ -114,34 +114,32 @@ class DropsTest < Minitest::Test
     assert_equal('  ', tpl.render!('product' => ProductDrop.new))
   end
 
-  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
-
-    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 }}')
+  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))

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,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/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/raw_tag_test.rb

@@ -14,6 +14,10 @@ class RawTagTest < Minitest::Test
     assert_template_result('{{ test }}', '{% raw %}{{ test }}{% endraw %}')
   end
 
+  def test_post_trim
+    assert_template_result('hi', "{% raw %}hi{% endraw -%}\n")
+  end
+
   def test_open_tag_in_raw
     assert_template_result(' Foobar {% invalid ', '{% raw %} Foobar {% invalid {% endraw %}')
     assert_template_result(' Foobar invalid %} ', '{% raw %} Foobar invalid %} {% endraw %}')

test/integration/tags/render_tag_test.rb

@@ -42,31 +42,29 @@ class RenderTagTest < Minitest::Test
     assert_template_result('', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}")
   end
 
-  if taint_supported?
-    def test_render_sets_the_correct_template_name_for_errors
-      Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
+  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
-      end
+      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 }}')
+  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
-      end
+      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+      assert_equal 'snippet', context.warnings.first.template_name
     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 memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
-    assert(t.resource_limits.render_length_reached?)
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.render_length_limit = 10
     assert_equal("0123456789", t.render!)
@@ -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 memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
-    assert(t.resource_limits.render_score_reached?)
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
-    assert(t.resource_limits.render_score_reached?)
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.render_score_limit = 200
     assert_equal((" foo " * 100), t.render!)
@@ -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 memory limit error: #{Liquid::MemoryError::ASSIGN_SCORE_ERROR_MESSAGE}", t.render)
-    assert(t.resource_limits.assign_score_reached?)
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.assign_score_limit = 2
     assert_equal("", t.render!)
@@ -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 memory limit error: #{Liquid::MemoryError::ASSIGN_SCORE_ERROR_MESSAGE}", t.render)
-    assert(t.resource_limits.assign_score_reached?)
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
 
     t.resource_limits.assign_score_limit = 5
     assert_equal("", t.render!)
@@ -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 memory limit error: #{Liquid::MemoryError::RENDER_SCORE_ERROR_MESSAGE}", t.render)
-    assert(t.resource_limits.render_score_reached?)
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
   end
 
   def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
@@ -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 memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    assert_equal("Liquid error: Memory limits exceeded", 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 memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    assert_equal("Liquid error: Memory limits exceeded", 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 memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
     t.resource_limits.render_length_limit = 11
-    assert_equal("Liquid memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    assert_equal("Liquid error: Memory limits exceeded", 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 memory limit error: #{Liquid::MemoryError::RENDER_LENGTH_ERROR_MESSAGE}", t.render)
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
     t.resource_limits.render_length_limit = 18
     assert_equal("すごい", t.render)
   end
@@ -361,12 +361,4 @@ 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,10 +32,6 @@ 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
@@ -58,39 +54,20 @@ 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)
@@ -159,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/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/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