[Strainer] Separate factory from template

lib/liquid.rb

@@ -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'

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/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

@@ -3,54 +3,39 @@
 require 'set'
 
 module Liquid
-  # Strainer is the parent class for the filters system.
+  # 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 Strainer.global_filter,
+  # 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 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
-
+  class StrainerTemplate
     def initialize(context)
       @context = context
     end
 
     class << self
-      attr_reader :filter_methods
-    end
+      def add_filter(filter)
+        return if include?(filter)
 
-    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
+
+        include(filter)
+
+        filter_methods.merge(filter.public_instance_methods.map(&:to_s))
       end
-    end
 
-    def self.global_filter(filter)
-      @@strainer_class_cache.clear
-      @@global_strainer.add_filter(filter)
-    end
+      def invokable?(method)
+        filter_methods.include?(method.to_s)
+      end
 
-    def self.invokable?(method)
-      @filter_methods.include?(method.to_s)
-    end
+      private
 
-    def self.create(context, filters = [])
-      @@strainer_class_cache[filters].new(context)
+      def filter_methods
+        @filter_methods ||= Set.new
+      end
     end
 
     def invoke(method, *args)

lib/liquid/template.rb

@@ -111,7 +111,7 @@ module Liquid
       # 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