rspec-rails 3.0.2 → 7.1.1

data/lib/rspec/rails/view_assigns.rb

@@ -13,34 +13,15 @@ module RSpec
       end
 
       # Compat-shim for AbstractController::Rendering#view_assigns
-      #
-      # _assigns was deprecated in favor of view_assigns after
-      # Rails-3.0.0 was released. Since we are not able to predict when
-      # the _assigns/view_assigns patch will be released (I thought it
-      # would have been in 3.0.1, but 3.0.1 bypassed this change for a
-      # security fix), this bit ensures that we do the right thing without
-      # knowing anything about the Rails version we are dealing with.
-      #
-      # Once that change _is_ released, this can be changed to something
-      # that checks for the Rails version when the module is being
-      # interpreted, as it was before commit dd0095.
       def view_assigns
         super.merge(_encapsulated_assigns)
-      rescue
-        _assigns
-      end
-
-      # @private
-      def _assigns
-        super.merge(_encapsulated_assigns)
       end
 
-      private
+    private
 
       def _encapsulated_assigns
         @_encapsulated_assigns ||= {}
       end
-
     end
   end
 end

data/lib/rspec/rails/view_path_builder.rb

@@ -0,0 +1,29 @@
+module RSpec
+  module Rails
+    # Builds paths for view specs using a particular route set.
+    class ViewPathBuilder
+      def initialize(route_set)
+        self.class.send(:include, route_set.url_helpers)
+      end
+
+      # Given a hash of parameters, build a view path, if possible.
+      # Returns nil if no path can be built from the given params.
+      #
+      # @example
+      #     # path can be built because all required params are present in the hash
+      #     view_path_builder = ViewPathBuilder.new(::Rails.application.routes)
+      #     view_path_builder.path_for({ :controller => 'posts', :action => 'show', :id => '54' })
+      #     # => "/post/54"
+      #
+      # @example
+      #     # path cannot be built because the params are missing a required element (:id)
+      #     view_path_builder.path_for({ :controller => 'posts', :action => 'delete' })
+      #     # => ActionController::UrlGenerationError: No route matches {:action=>"delete", :controller=>"posts"}
+      def path_for(path_params)
+        url_for(path_params.merge(only_path: true))
+      rescue => e
+        e.message
+      end
+    end
+  end
+end

data/lib/rspec/rails/view_rendering.rb

@@ -2,16 +2,23 @@ require 'action_view/testing/resolvers'
 
 module RSpec
   module Rails
+    # @api public
     # Helpers for optionally rendering views in controller specs.
     module ViewRendering
       extend ActiveSupport::Concern
 
-      attr_accessor :controller
+      # @!attribute [r]
+      # Returns the controller object instance under test.
+      attr_reader :controller
+
+      # @private
+      attr_writer :controller
+      private :controller=
 
       # DSL methods
       module ClassMethods
         # @see RSpec::Rails::ControllerExampleGroup
-        def render_views(true_or_false=true)
+        def render_views(true_or_false = true)
           @render_views = true_or_false
         end
 
@@ -32,35 +39,85 @@ module RSpec
         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 EmptyTemplatePathSetDecorator < ::ActionView::Resolver
-        attr_reader :original_path_set
-
-        def initialize(original_path_set)
-          @original_path_set = original_path_set
+      class EmptyTemplateResolver
+        def self.build(path)
+          if path.is_a?(::ActionView::Resolver)
+            ResolverDecorator.new(path)
+          else
+            FileSystemResolver.new(path)
+          end
         end
 
-        def find_all(*args)
-          original_path_set.find_all(*args).collect do |template|
+        def self.nullify_template_rendering(templates)
+          templates.map do |template|
             ::ActionView::Template.new(
               "",
               template.identifier,
               EmptyTemplateHandler,
-              {
-                :virtual_path => template.virtual_path,
-                :format => template.formats
-              }
+              virtual_path: template.virtual_path,
+              format: template_format(template),
+              locals: []
             )
           end
         end
+
+        def self.template_format(template)
+          template.format
+        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 < ::ActionView::Resolver
+          (::ActionView::Resolver.instance_methods - Object.instance_methods).each do |method|
+            undef_method method
+          end
+
+          (::ActionView::Resolver.methods - Object.methods).each do |method|
+            singleton_class.undef_method method
+          end
+
+          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
       class EmptyTemplateHandler
-        def self.call(template)
+        def self.call(_template, _source = nil)
+          ::Rails.logger.info("  Template rendering was prevented by rspec-rails. Use `render_views` to verify rendered view contents if necessary.")
+
           %("")
         end
       end
@@ -70,33 +127,38 @@ module RSpec
       # @private
       module EmptyTemplates
         def prepend_view_path(new_path)
-          lookup_context.view_paths.unshift(*_path_decorator(new_path))
+          super(_path_decorator(*new_path))
         end
 
         def append_view_path(new_path)
-          lookup_context.view_paths.push(*_path_decorator(new_path))
+          super(_path_decorator(*new_path))
         end
 
-        private
+      private
 
-        def _path_decorator(path)
-          EmptyTemplatePathSetDecorator.new(ActionView::PathSet.new(Array.wrap(path)))
+        def _path_decorator(*paths)
+          paths.map { |path| EmptyTemplateResolver.build(path) }
         end
       end
 
+      # @private
+      RESOLVER_CACHE = Hash.new do |hash, path|
+        hash[path] = EmptyTemplateResolver.build(path)
+      end
+
       included do
         before do
           unless render_views?
-            @_empty_view_path_set_delegator = EmptyTemplatePathSetDecorator.new(controller.class.view_paths)
-            controller.class.view_paths = ::ActionView::PathSet.new.push(@_empty_view_path_set_delegator)
+            @_original_path_set = controller.class.view_paths
+            path_set = @_original_path_set.map { |resolver| RESOLVER_CACHE[resolver] }
+
+            controller.class.view_paths = path_set
             controller.extend(EmptyTemplates)
           end
         end
 
         after do
-          unless render_views?
-            controller.class.view_paths = @_empty_view_path_set_delegator.original_path_set
-          end
+          controller.class.view_paths = @_original_path_set unless render_views?
         end
       end
     end

data/lib/rspec/rails/view_spec_methods.rb

@@ -0,0 +1,56 @@
+module RSpec
+  module Rails
+    # Adds methods (generally to ActionView::TestCase::TestController).
+    # Intended for use in view specs.
+    module ViewSpecMethods
+      module_function
+
+      # Adds methods `extra_params=` and `extra_params` to the indicated class.
+      # When class is `::ActionView::TestCase::TestController`, these methods
+      # are exposed in view specs on the `controller` object.
+      def add_to(klass)
+        return if klass.method_defined?(:extra_params) && klass.method_defined?(:extra_params=)
+
+        klass.module_exec do
+          # Set any extra parameters that rendering a URL for this view
+          # would require.
+          #
+          # @example
+          #
+          #     # In "spec/views/widgets/show.html.erb_spec.rb":
+          #     before do
+          #       widget = Widget.create!(:name => "slicer")
+          #       controller.extra_params = { :id => widget.id }
+          #     end
+          def extra_params=(hash)
+            @extra_params = hash
+            request.path =
+              ViewPathBuilder.new(::Rails.application.routes).path_for(
+                extra_params.merge(request.path_parameters)
+              )
+          end
+
+          # Use to read extra parameters that are set in the view spec.
+          #
+          # @example
+          #
+          #     # After the before in the above example:
+          #     controller.extra_params
+          #     # => { :id => 4 }
+          def extra_params
+            @extra_params ||= {}
+            @extra_params.dup.freeze
+          end
+        end
+      end
+
+      # Removes methods `extra_params=` and `extra_params` from the indicated class.
+      def remove_from(klass)
+        klass.module_exec do
+          undef extra_params= if klass.method_defined?(:extra_params=)
+          undef extra_params  if klass.method_defined?(:extra_params)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/rails.rb

@@ -1,10 +1,18 @@
 require 'rspec/core'
 require 'rails/version'
+
+# Load any of our adapters and extensions early in the process
+require 'rspec/rails/adapters'
 require 'rspec/rails/extensions'
+
+# Load the rspec-rails parts
 require 'rspec/rails/view_rendering'
-require 'rspec/rails/adapters'
 require 'rspec/rails/matchers'
 require 'rspec/rails/fixture_support'
+require 'rspec/rails/file_fixture_support'
+require 'rspec/rails/fixture_file_upload_support'
 require 'rspec/rails/example'
 require 'rspec/rails/vendor/capybara'
 require 'rspec/rails/configuration'
+require 'rspec/rails/active_record'
+require 'rspec/rails/feature_check'

data/lib/rspec-rails.rb

@@ -1,17 +1,97 @@
+require 'rspec/rails/feature_check'
+
 # Namespace for all core RSpec projects.
 module RSpec
   # Namespace for rspec-rails code.
   module Rails
     # Railtie to hook into Rails.
     class Railtie < ::Rails::Railtie
-      # Rails-3.0.1 requires config.app_generators instead of 3.0.0's config.generators
-      generators = config.respond_to?(:app_generators) ? config.app_generators : config.generators
+      # As of Rails 5.1.0 you can register directories to work with `rake notes`
+      require 'rails/source_annotation_extractor'
+      ::Rails::SourceAnnotationExtractor::Annotation.register_directories("spec")
+
+      # As of Rails 8.0.0 you can register directories to work with `rails stats`
+      if ::Rails::VERSION::STRING >= "8.0.0"
+        require 'rails/code_statistics'
+
+        dirs = Dir['./spec/**/*_spec.rb']
+          .map { |f| f.sub(/^\.\/(spec\/\w+)\/.*/, '\\1') }
+          .uniq
+          .select { |f| File.directory?(f) }
+
+        Hash[dirs.map { |d| [d.split('/').last, d] }].each do |type, dir|
+          name = type.singularize.capitalize
+
+          ::Rails::CodeStatistics.register_directory "#{name} specs", dir, test_directory: true
+        end
+      end
+
+      generators = config.app_generators
       generators.integration_tool :rspec
-      generators.test_framework   :rspec
+      generators.test_framework :rspec
+
+      generators do
+        ::Rails::Generators.hidden_namespaces.reject! { |namespace| namespace.to_s.start_with?("rspec") }
+      end
 
       rake_tasks do
         load "rspec/rails/tasks/rspec.rake"
       end
+
+      # This is called after the environment has been loaded but before Rails
+      # sets the default for the `preview_path`
+      initializer "rspec_rails.action_mailer",
+                  before: "action_mailer.set_configs" do |app|
+                    setup_preview_path(app)
+                  end
+
+    private
+
+      def setup_preview_path(app)
+        return unless supports_action_mailer_previews?(app.config)
+
+        options = app.config.action_mailer
+        config_default_preview_path(options) if config_preview_path?(options)
+      end
+
+      def config_preview_path?(options)
+        # We cannot use `respond_to?(:show_previews)` here as it will always
+        # return `true`.
+        if options.show_previews.nil?
+          options.show_previews = ::Rails.env.development?
+        else
+          options.show_previews
+        end
+      end
+
+      if ::Rails::VERSION::STRING >= "7.1.0"
+        def config_default_preview_path(options)
+          return unless options.preview_paths.empty?
+
+          options.preview_paths << "#{::Rails.root}/spec/mailers/previews"
+        end
+      else
+        def config_default_preview_path(options)
+          return unless options.preview_path.blank?
+
+          options.preview_path = "#{::Rails.root}/spec/mailers/previews"
+        end
+      end
+
+      def supports_action_mailer_previews?(config)
+        # These checks avoid loading `ActionMailer`. Using `defined?` has the
+        # side-effect of the class getting loaded if it is available. This is
+        # problematic because loading `ActionMailer::Base` will cause it to
+        # read the config settings; this is the only time the config is read.
+        # If the config is loaded now, any settings declared in a config block
+        # in an initializer will be ignored.
+        #
+        # If the action mailer railtie has not been loaded then `config` will
+        # not respond to the method. However, we cannot use
+        # `config.action_mailer.respond_to?(:preview_path)` here as it will
+        # always return `true`.
+        config.respond_to?(:action_mailer)
+      end
     end
   end
 end