Delegate properly to custom Resolver instances

Let `EmptyTemplateResolver` creating instances of either
`EmptyTemplateResolver::ResolverDecorator` or
`EmptyTemplateResolver::FileSystemResolver`, depending on whether the given path
is an `ActionView::Resolver` instance or not.

The new `EmptyTemplateResolver::ResolverDecorator` class simply delegates all
method calls to its given resolver, checks the return values, and changes
collections of `ActionView::Template` instances into templates that render with
`EmptyTemplateHandler`.

The alternative was to implement both `#find_all` and `#find_all_anywhere`. The
latter is only present since Rails 4.2.5.1, and the former has different arity
in different Rails versions.

Author: bquorning

lib/rspec/rails/view_rendering.rb

@@ -39,15 +39,18 @@ def render_views?
         self.class.render_views? || !controller.class.respond_to?(:view_paths)
       end
 
-      # Delegates find_all to the submitted path set and then returns templates
-      # with modified source
-      #
       # @private
-      class EmptyTemplateResolver < ::ActionView::FileSystemResolver
-      private
+      class EmptyTemplateResolver
+        def self.build(path)
+          if path.is_a?(::ActionView::Resolver)
+            ResolverDecorator.new(path)
+          else
+            FileSystemResolver.new(path)
+          end
+        end
 
-        def find_templates(*args)
-          super.map do |template|
+        def self.nullify_template_rendering(templates)
+          templates.map do |template|
             ::ActionView::Template.new(
               "",
               template.identifier,
@@ -57,6 +60,44 @@ def find_templates(*args)
             )
           end
         end
+
+        # Delegates all methods to the submitted resolver and for all methods
+        # that return a collection of `ActionView::Template` instances, return
+        # templates with modified source
+        #
+        # @private
+        class ResolverDecorator
+          def initialize(resolver)
+            @resolver = resolver
+          end
+
+          def method_missing(name, *args, &block)
+            result = @resolver.send(name, *args, &block)
+            nullify_templates(result)
+          end
+
+        private
+
+          def nullify_templates(collection)
+            return collection unless collection.is_a?(Enumerable)
+            return collection unless collection.all? { |element| element.is_a?(::ActionView::Template) }
+
+            EmptyTemplateResolver.nullify_template_rendering(collection)
+          end
+        end
+
+        # Delegates find_templates to the submitted path set and then returns
+        # templates with modified source
+        #
+        # @private
+        class FileSystemResolver < ::ActionView::FileSystemResolver
+        private
+
+          def find_templates(*args)
+            templates = super
+            EmptyTemplateResolver.nullify_template_rendering(templates)
+          end
+        end
       end
 
       # @private
@@ -81,13 +122,13 @@ def append_view_path(new_path)
       private
 
         def _path_decorator(*paths)
-          paths.map { |path| EmptyTemplateResolver.new(path) }
+          paths.map { |path| EmptyTemplateResolver.build(path) }
         end
       end
 
       # @private
       RESOLVER_CACHE = Hash.new do |hash, path|
-        hash[path] = EmptyTemplateResolver.new(path)
+        hash[path] = EmptyTemplateResolver.build(path)
       end
 
       included do

spec/rspec/rails/view_rendering_spec.rb

@@ -139,6 +139,13 @@ def example.controller
         expect(controller.view_paths.map(&:to_s)).to match_paths 'app/views', 'app/legacy_views', 'app/others', 'app/more_views'
       end
 
+      it 'supports manipulating view paths with resolvers' do
+        expect {
+          controller.prepend_view_path ActionView::Resolver.new
+          controller.append_view_path ActionView::Resolver.new
+        }.to_not raise_error
+      end
+
       def match_paths(*paths)
         eq paths.map { |path| File.expand_path path }
       end