rspec-core 3.13.5 → 4.0.0.beta1

data/lib/rspec/core/metadata.rb

@@ -46,10 +46,6 @@ module RSpec
         line = line.sub(/\A([^:]+:\d+)$/, '\\1'.freeze)
         return nil if line == '-e:1'.freeze
         line
-      rescue SecurityError
-        # :nocov: - SecurityError is no longer produced starting in ruby 2.7
-        nil
-        # :nocov:
       end
 
       # @private
@@ -77,16 +73,11 @@ module RSpec
       # Symbols are converted into hash keys with a value of `true`.
       # This is done to support simple tagging using a symbol, rather
       # than needing to do `:symbol => true`.
-      def self.build_hash_from(args, warn_about_example_group_filtering=false)
+      def self.build_hash_from(args)
         hash = args.last.is_a?(Hash) ? args.pop : {}
 
         hash[args.pop] = true while args.last.is_a?(Symbol)
 
-        if warn_about_example_group_filtering && hash.key?(:example_group)
-          RSpec.deprecate("Filtering by an `:example_group` subhash",
-                          :replacement => "the subhash to filter directly")
-        end
-
         hash
       end
 
@@ -146,7 +137,7 @@ module RSpec
           file_path, line_number = if backtrace
                                      file_path_and_line_number_from(backtrace)
                                    elsif block.respond_to?(:source_location)
-                                     block.source_location
+                                     block.source_location.take(2)
                                    else
                                      file_path_and_line_number_from(caller)
                                    end
@@ -213,11 +204,6 @@ module RSpec
       class ExampleHash < HashPopulator
         def self.create(group_metadata, user_metadata, index_provider, description, block)
           example_metadata = group_metadata.dup
-          group_metadata = Hash.new(&ExampleGroupHash.backwards_compatibility_default_proc do |hash|
-            hash[:parent_example_group]
-          end)
-          group_metadata.update(example_metadata)
-
           example_metadata[:execution_result] = Example::ExecutionResult.new
           example_metadata[:example_group] = group_metadata
           example_metadata[:shared_group_inclusion_backtrace] = SharedExampleGroupInclusionStackFrame.current_backtrace
@@ -246,59 +232,18 @@ module RSpec
       # @private
       class ExampleGroupHash < HashPopulator
         def self.create(parent_group_metadata, user_metadata, example_group_index, *args, &block)
-          group_metadata = hash_with_backwards_compatibility_default_proc
-
-          if parent_group_metadata
-            group_metadata.update(parent_group_metadata)
-            group_metadata[:parent_example_group] = parent_group_metadata
-          end
+          group_metadata =
+            if parent_group_metadata
+              { **parent_group_metadata, :parent_example_group => parent_group_metadata }
+            else
+              {}
+            end
 
           hash = new(group_metadata, user_metadata, example_group_index, args, block)
           hash.populate
           hash.metadata
         end
 
-        def self.hash_with_backwards_compatibility_default_proc
-          Hash.new(&backwards_compatibility_default_proc { |hash| hash })
-        end
-
-        def self.backwards_compatibility_default_proc(&example_group_selector)
-          Proc.new do |hash, key|
-            case key
-            when :example_group
-              # We commonly get here when rspec-core is applying a previously
-              # configured filter rule, such as when a gem configures:
-              #
-              #   RSpec.configure do |c|
-              #     c.include MyGemHelpers, :example_group => { :file_path => /spec\/my_gem_specs/ }
-              #   end
-              #
-              # It's confusing for a user to get a deprecation at this point in
-              # the code, so instead we issue a deprecation from the config APIs
-              # that take a metadata hash, and MetadataFilter sets this thread
-              # local to silence the warning here since it would be so
-              # confusing.
-              unless RSpec::Support.thread_local_data[:silence_metadata_example_group_deprecations]
-                RSpec.deprecate("The `:example_group` key in an example group's metadata hash",
-                                :replacement => "the example group's hash directly for the " \
-                                "computed keys and `:parent_example_group` to access the parent " \
-                                "example group metadata")
-              end
-
-              group_hash = example_group_selector.call(hash)
-              LegacyExampleGroupHash.new(group_hash) if group_hash
-            when :example_group_block
-              RSpec.deprecate("`metadata[:example_group_block]`",
-                              :replacement => "`metadata[:block]`")
-              hash[:block]
-            when :describes
-              RSpec.deprecate("`metadata[:describes]`",
-                              :replacement => "`metadata[:described_class]`")
-              hash[:described_class]
-            end
-          end
-        end
-
       private
 
         def described_class
@@ -341,158 +286,5 @@ module RSpec
         :shared_group_inclusion_backtrace
       ]
     end
-
-    # Mixin that makes the including class imitate a hash for backwards
-    # compatibility. The including class should use `attr_accessor` to
-    # declare attributes.
-    # @private
-    module HashImitatable
-      def self.included(klass)
-        klass.extend ClassMethods
-      end
-
-      def to_h
-        hash = extra_hash_attributes.dup
-
-        self.class.hash_attribute_names.each do |name|
-          hash[name] = __send__(name)
-        end
-
-        hash
-      end
-
-      (Hash.public_instance_methods - Object.public_instance_methods).each do |method_name|
-        next if [:[], :[]=, :to_h].include?(method_name.to_sym)
-
-        define_method(method_name) do |*args, &block|
-          issue_deprecation(method_name, *args)
-
-          hash = hash_for_delegation
-          self.class.hash_attribute_names.each do |name|
-            hash.delete(name) unless instance_variable_defined?(:"@#{name}")
-          end
-
-          hash.__send__(method_name, *args, &block).tap do
-            # apply mutations back to the object
-            hash.each do |name, value|
-              if directly_supports_attribute?(name)
-                set_value(name, value)
-              else
-                extra_hash_attributes[name] = value
-              end
-            end
-          end
-        end
-      end
-
-      def [](key)
-        issue_deprecation(:[], key)
-
-        if directly_supports_attribute?(key)
-          get_value(key)
-        else
-          extra_hash_attributes[key]
-        end
-      end
-
-      def []=(key, value)
-        issue_deprecation(:[]=, key, value)
-
-        if directly_supports_attribute?(key)
-          set_value(key, value)
-        else
-          extra_hash_attributes[key] = value
-        end
-      end
-
-    private
-
-      def extra_hash_attributes
-        @extra_hash_attributes ||= {}
-      end
-
-      def directly_supports_attribute?(name)
-        self.class.hash_attribute_names.include?(name)
-      end
-
-      def get_value(name)
-        __send__(name)
-      end
-
-      def set_value(name, value)
-        __send__(:"#{name}=", value)
-      end
-
-      def hash_for_delegation
-        to_h
-      end
-
-      def issue_deprecation(_method_name, *_args)
-        # no-op by default: subclasses can override
-      end
-
-      # @private
-      module ClassMethods
-        def hash_attribute_names
-          @hash_attribute_names ||= []
-        end
-
-        def attr_accessor(*names)
-          hash_attribute_names.concat(names)
-          super
-        end
-      end
-    end
-
-    # @private
-    # Together with the example group metadata hash default block,
-    # provides backwards compatibility for the old `:example_group`
-    # key. In RSpec 2.x, the computed keys of a group's metadata
-    # were exposed from a nested subhash keyed by `[:example_group]`, and
-    # then the parent group's metadata was exposed by sub-subhash
-    # keyed by `[:example_group][:example_group]`.
-    #
-    # In RSpec 3, we reorganized this to that the computed keys are
-    # exposed directly of the group metadata hash (no nesting), and
-    # `:parent_example_group` returns the parent group's metadata.
-    #
-    # Maintaining backwards compatibility was difficult: we wanted
-    # `:example_group` to return an object that:
-    #
-    #   * Exposes the top-level metadata keys that used to be nested
-    #     under `:example_group`.
-    #   * Supports mutation (rspec-rails, for example, assigns
-    #     `metadata[:example_group][:described_class]` when you use
-    #     anonymous controller specs) such that changes are written
-    #     back to the top-level metadata hash.
-    #   * Exposes the parent group metadata as
-    #     `[:example_group][:example_group]`.
-    class LegacyExampleGroupHash
-      include HashImitatable
-
-      def initialize(metadata)
-        @metadata = metadata
-        parent_group_metadata = metadata.fetch(:parent_example_group) { {} }[:example_group]
-        self[:example_group] = parent_group_metadata if parent_group_metadata
-      end
-
-      def to_h
-        super.merge(@metadata)
-      end
-
-    private
-
-      def directly_supports_attribute?(name)
-        name != :example_group
-      end
-
-      def get_value(name)
-        @metadata[name]
-      end
-
-      def set_value(name, value)
-        @metadata[name] = value
-      end
-    end
   end
 end

data/lib/rspec/core/metadata_filter.rb

@@ -8,33 +8,23 @@ module RSpec
     module MetadataFilter
       class << self
         # @private
-        def apply?(predicate, filters, metadata)
-          filters.__send__(predicate) { |k, v| filter_applies?(k, v, metadata) }
+        def apply?(filters, metadata)
+          filters.all? { |k, v| filter_applies?(k, v, metadata) }
         end
 
         # @private
         def filter_applies?(key, filter_value, metadata)
-          silence_metadata_example_group_deprecations do
-            return location_filter_applies?(filter_value, metadata) if key == :locations
-            return id_filter_applies?(filter_value, metadata)       if key == :ids
-            return filters_apply?(key, filter_value, metadata)      if Hash === filter_value
+          return location_filter_applies?(filter_value, metadata) if key == :locations
+          return id_filter_applies?(filter_value, metadata)       if key == :ids
+          return filters_apply?(key, filter_value, metadata)      if Hash === filter_value
 
-            meta_value = metadata.fetch(key) { return false }
+          meta_value = metadata.fetch(key) { return false }
 
-            return true if TrueClass === filter_value && meta_value
-            return proc_filter_applies?(key, filter_value, metadata) if Proc === filter_value
-            return filter_applies_to_any_value?(key, filter_value, metadata) if Array === meta_value
+          return true if TrueClass === filter_value && meta_value
+          return proc_filter_applies?(key, filter_value, metadata) if Proc === filter_value
+          return filter_applies_to_any_value?(key, filter_value, metadata) if Array === meta_value
 
-            filter_value === meta_value || filter_value.to_s == meta_value.to_s
-          end
-        end
-
-        # @private
-        def silence_metadata_example_group_deprecations
-          RSpec::Support.thread_local_data[:silence_metadata_example_group_deprecations] = true
-          yield
-        ensure
-          RSpec::Support.thread_local_data.delete(:silence_metadata_example_group_deprecations)
+          filter_value === meta_value || filter_value.to_s == meta_value.to_s
         end
 
       private
@@ -72,7 +62,7 @@ module RSpec
 
         def filters_apply?(key, value, metadata)
           subhash = metadata[key]
-          return false unless Hash === subhash || HashImitatable === subhash
+          return false unless Hash === subhash
           value.all? { |k, v| filter_applies?(k, v, subhash) }
         end
       end
@@ -98,8 +88,7 @@ module RSpec
       class UpdateOptimized
         attr_reader :items_and_filters
 
-        def initialize(applies_predicate)
-          @applies_predicate = applies_predicate
+        def initialize
           @items_and_filters = []
         end
 
@@ -118,21 +107,8 @@ module RSpec
         def items_for(request_meta)
           @items_and_filters.each_with_object([]) do |(item, item_meta), to_return|
             to_return << item if item_meta.empty? ||
-                                 MetadataFilter.apply?(@applies_predicate, item_meta, request_meta)
-          end
-        end
-
-        unless [].respond_to?(:each_with_object) # For 1.8.7
-          # :nocov:
-          undef items_for
-          def items_for(request_meta)
-            @items_and_filters.inject([]) do |to_return, (item, item_meta)|
-              to_return << item if item_meta.empty? ||
-                                   MetadataFilter.apply?(@applies_predicate, item_meta, request_meta)
-              to_return
-            end
+                                 MetadataFilter.apply?(item_meta, request_meta)
           end
-          # :nocov:
         end
       end
 
@@ -152,7 +128,7 @@ module RSpec
         alias find_items_for items_for
         private :find_items_for
 
-        def initialize(applies_predicate)
+        def initialize
           super
           @applicable_keys   = Set.new
           @proc_keys         = Set.new
@@ -187,7 +163,7 @@ module RSpec
           # that are not. For each set, this method for the first group in the set is
           # still an `O(N)` calculation, but all subsequent groups in the set will be
           # constant time lookups when they call this method.
-          applicable_metadata = applicable_metadata_from(metadata)
+          applicable_metadata = metadata.slice(*@applicable_keys)
 
           if applicable_metadata.any? { |k, _| @proc_keys.include?(k) }
             # It's unsafe to memoize lookups involving procs (since they can
@@ -214,41 +190,11 @@ module RSpec
           @memoized_lookups.clear
         end
 
-        def applicable_metadata_from(metadata)
-          MetadataFilter.silence_metadata_example_group_deprecations do
-            @applicable_keys.inject({}) do |hash, key|
-              # :example_group is treated special here because...
-              # - In RSpec 2, example groups had an `:example_group` key
-              # - In RSpec 3, that key is deprecated (it was confusing!).
-              # - The key is not technically present in an example group metadata hash
-              #   (and thus would fail the `metadata.key?(key)` check) but a value
-              #   is provided when accessed via the hash's `default_proc`
-              # - Thus, for backwards compatibility, we have to explicitly check
-              #   for `:example_group` here if it is one of the keys being used to
-              #   filter.
-              hash[key] = metadata[key] if metadata.key?(key) || key == :example_group
-              hash
-            end
-          end
-        end
-
         def proc_keys_from(metadata)
           metadata.each_with_object([]) do |(key, value), to_return|
             to_return << key if Proc === value
           end
         end
-
-        unless [].respond_to?(:each_with_object) # For 1.8.7
-          # :nocov:
-          undef proc_keys_from
-          def proc_keys_from(metadata)
-            metadata.inject([]) do |to_return, (key, value)|
-              to_return << key if Proc === value
-              to_return
-            end
-          end
-          # :nocov:
-        end
       end
     end
   end

data/lib/rspec/core/minitest_assertions_adapter.rb

@@ -1,9 +1,9 @@
 begin
-  # Only the minitest 5.x gem includes the minitest.rb and assertions.rb files.
+  # Only Minitest 5.x includes minitest.rb and assertions.rb files
   require 'minitest'
   require 'minitest/assertions'
 rescue LoadError
-  # We must be using Ruby Core's MiniTest or the Minitest gem 4.x.
+  # We must be using Minitest 4.x
   require 'minitest/unit'
   Minitest = MiniTest
 end

data/lib/rspec/core/mocking_adapters/mocha.rb

@@ -1,28 +1,4 @@
-# In order to support all versions of mocha, we have to jump through some
-# hoops here.
-#
-# mocha >= '0.13.0':
-#   require 'mocha/api' is required.
-#   require 'mocha/object' raises a LoadError b/c the file no longer exists.
-# mocha < '0.13.0', >= '0.9.7'
-#   require 'mocha/api' is required.
-#   require 'mocha/object' is required.
-# mocha < '0.9.7':
-#   require 'mocha/api' raises a LoadError b/c the file does not yet exist.
-#   require 'mocha/standalone' is required.
-#   require 'mocha/object' is required.
-begin
-  require 'mocha/api'
-
-  begin
-    require 'mocha/object'
-  rescue LoadError
-    # Mocha >= 0.13.0 no longer contains this file nor needs it to be loaded.
-  end
-rescue LoadError
-  require 'mocha/standalone'
-  require 'mocha/object'
-end
+require 'mocha/api'
 
 module RSpec
   module Core
@@ -33,12 +9,7 @@ module RSpec
           :mocha
         end
 
-        # Mocha::Standalone was deprecated as of Mocha 0.9.7.
-        begin
-          include ::Mocha::API
-        rescue NameError
-          include ::Mocha::Standalone
-        end
+        include ::Mocha::API
 
         def setup_mocks_for_rspec
           mocha_setup

data/lib/rspec/core/notifications.rb

@@ -42,17 +42,9 @@ module RSpec::Core
         execution_result = example.execution_result
 
         return SkippedExampleNotification.new(example) if execution_result.example_skipped?
-        return new(example) unless execution_result.status == :pending || execution_result.status == :failed
+        return FailedExampleNotification.new(example) if execution_result.status == :pending || execution_result.status == :failed
 
-        klass = if execution_result.pending_fixed?
-                  PendingExampleFixedNotification
-                elsif execution_result.status == :pending
-                  PendingExampleFailedAsExpectedNotification
-                else
-                  FailedExampleNotification
-                end
-
-        klass.new(example)
+        new(example)
       end
 
       private_class_method :new
@@ -216,12 +208,6 @@ module RSpec::Core
       end
     end
 
-    # @deprecated Use {FailedExampleNotification} instead.
-    class PendingExampleFixedNotification < FailedExampleNotification; end
-
-    # @deprecated Use {FailedExampleNotification} instead.
-    class PendingExampleFailedAsExpectedNotification < FailedExampleNotification; end
-
     # The `SkippedExampleNotification` extends `ExampleNotification` with
     # things useful for specs that are skipped.
     #
@@ -401,7 +387,9 @@ module RSpec::Core
 
       def rerun_argument_for(example)
         location = example.location_rerun_argument
+
         return location unless duplicate_rerun_locations.include?(location)
+        return location if RSpec.configuration.force_line_number_for_spec_rerun
         conditionally_quote(example.id)
       end
 

data/lib/rspec/core/option_parser.rb

@@ -18,7 +18,7 @@ module RSpec::Core
       return { :files_or_directories_to_run => [] } if original_args.empty?
       args = original_args.dup
 
-      options = args.delete('--tty') ? { :tty => true } : {}
+      options = {}
       begin
         parser(options).parse!(args)
       rescue OptionParser::InvalidOption => e
@@ -139,12 +139,6 @@ module RSpec::Core
           options[:full_backtrace] = true
         end
 
-        parser.on('-c', '--color', '--colour', '') do |_o|
-          # flag will be excluded from `--help` output because it is deprecated
-          options[:color] = true
-          options[:color_mode] = :automatic
-        end
-
         parser.on('--force-color', '--force-colour', 'Force the output to be in color, even if the output is not a TTY') do |_o|
           if options[:color_mode] == :off
             abort "Please only use one of `--force-color` and `--no-color`"
@@ -170,8 +164,8 @@ module RSpec::Core
                                            Integer(argument)
                                          rescue ArgumentError
                                            RSpec.warning "Non integer specified as profile count, separate " \
-                                                       "your path from options with -- e.g. " \
-                                                       "`rspec --profile -- #{argument}`",
+                                                         "your path from options with -- e.g. " \
+                                                         "`rspec --profile -- #{argument}`",
                                                          :call_site => nil
                                            true
                                          end
@@ -184,11 +178,7 @@ module RSpec::Core
         end
 
         parser.on('-w', '--warnings', 'Enable ruby warnings') do
-          if Object.const_defined?(:Warning) && Warning.respond_to?(:[]=)
-            # :nocov: on older Ruby without Warning
-            Warning[:deprecated] = true
-            # :nocov:
-          end
+          Warning[:deprecated] = true
           $VERBOSE = true
         end
 
@@ -252,6 +242,7 @@ FILTERING
           name, value = tag.gsub(/^(~@|~|@)/, '').split(':', 2)
           name = name.to_sym
 
+          # rubocop:disable Lint/DuplicateBranch
           parsed_value = case value
                          when  nil        then true # The default value for tags is true
                          when 'true'      then true
@@ -263,6 +254,7 @@ FILTERING
                          else
                            value
                          end
+          # rubocop:enable Lint/DuplicateBranch
 
           add_tag_filter(options, filter_type, name, parsed_value)
         end

data/lib/rspec/core/ordering.rb

@@ -109,14 +109,13 @@ module RSpec
           @configuration = configuration
           @strategies    = {}
 
-          register(:random, Random.new(configuration))
+          random = Random.new(configuration)
+          register(:random, random)
           register(:recently_modified, RecentlyModified.new)
+          register(:defined, Identity.new)
 
-          identity = Identity.new
-          register(:defined, identity)
-
-          # The default global ordering is --defined.
-          register(:global, identity)
+          # The default global ordering is --random.
+          register(:global, random)
         end
 
         def fetch(name, &fallback)

data/lib/rspec/core/output_wrapper.rb

@@ -10,8 +10,8 @@ module RSpec
         @output = output
       end
 
-      def respond_to?(name, priv=false)
-        output.respond_to?(name, priv)
+      def respond_to?(*args)
+        output.respond_to?(*args)
       end
 
       def method_missing(name, *args, &block)

data/lib/rspec/core/pending.rb

@@ -64,15 +64,7 @@ module RSpec
 
         if block_given?
           raise ArgumentError, <<-EOS.gsub(/^\s+\|/, '')
-            |The semantics of `RSpec::Core::Pending#pending` have changed in
-            |RSpec 3. In RSpec 2.x, it caused the example to be skipped. In
-            |RSpec 3, the rest of the example is still run but is expected to
-            |fail, and will be marked as a failure (rather than as pending) if
-            |the example passes.
-            |
-            |Passing a block within an example is now deprecated. Marking the
-            |example as pending provides the same behavior in RSpec 3 which was
-            |provided only by the block in RSpec 2.x.
+            |Passing a block within an example is not supported.
             |
             |Move the code in the block provided to `pending` into the rest of
             |the example body.