opal-rspec 0.8.0 → 1.0.0.alpha1

data/rspec-core/upstream/lib/rspec/core/configuration.rb

@@ -1,17 +1,32 @@
 RSpec::Support.require_rspec_core "backtrace_formatter"
 RSpec::Support.require_rspec_core "ruby_project"
 RSpec::Support.require_rspec_core "formatters/deprecation_formatter"
+RSpec::Support.require_rspec_core "output_wrapper"
 
 module RSpec
   module Core
-    # rubocop:disable Style/ClassLength
+    # rubocop:disable Metrics/ClassLength
 
     # Stores runtime configuration information.
     #
-    # Configuration options are loaded from `~/.rspec`, `.rspec`,
-    # `.rspec-local`, command line switches, and the `SPEC_OPTS` environment
-    # variable (listed in lowest to highest precedence; for example, an option
-    # in `~/.rspec` can be overridden by an option in `.rspec-local`).
+    # Configuration options are loaded from multiple files and joined together
+    # with command-line switches and the `SPEC_OPTS` environment variable.
+    #
+    # Precedence order (where later entries overwrite earlier entries on
+    # conflicts):
+    #
+    #   * Global (`$XDG_CONFIG_HOME/rspec/options`, or `~/.rspec` if it does
+    #     not exist)
+    #   * Project-specific (`./.rspec`)
+    #   * Local (`./.rspec-local`)
+    #   * Command-line options
+    #   * `SPEC_OPTS`
+    #
+    # For example, an option set in the local file will override an option set
+    # in your global file.
+    #
+    # The global, project-specific and local files can all be overridden with a
+    # separate custom file using the --options command-line parameter.
     #
     # @example Standard settings
     #     RSpec.configure do |c|
@@ -32,27 +47,37 @@ module RSpec
     class Configuration
       include RSpec::Core::Hooks
 
+      # Module that holds `attr_reader` declarations. It's in a separate
+      # module to allow us to override those methods and use `super`.
+      # @private
+      Readers = Module.new
+      include Readers
+
       # @private
       class MustBeConfiguredBeforeExampleGroupsError < StandardError; end
 
       # @private
       def self.define_reader(name)
-        define_method(name) do
-          variable = instance_variable_defined?("@#{name}") ? instance_variable_get("@#{name}") : nil
-          value_for(name, variable)
+        Readers.class_eval do
+          remove_method name if method_defined?(name)
+          attr_reader name
         end
+
+        define_method(name) { value_for(name) { super() } }
       end
 
       # @private
-      def self.define_aliases(name, alias_name)
+      def self.define_alias(name, alias_name)
         alias_method alias_name, name
         alias_method "#{alias_name}=", "#{name}="
-        define_predicate_for alias_name
+        define_predicate alias_name
       end
 
       # @private
-      def self.define_predicate_for(*names)
-        names.each { |name| alias_method "#{name}?", name }
+      def self.define_predicate(name)
+        define_method "#{name}?" do
+          !!send(name)
+        end
       end
 
       # @private
@@ -65,22 +90,21 @@ module RSpec
         add_read_only_setting name
 
         Array(opts[:alias_with]).each do |alias_name|
-          define_aliases(name, alias_name)
+          define_alias(name, alias_name)
         end
       end
 
       # @private
       #
-      # As `add_setting` but only add the reader
+      # As `add_setting` but only add the reader.
       def self.add_read_only_setting(name, opts={})
         raise "Use the instance add_setting method if you want to set a default" if opts.key?(:default)
         define_reader name
-        define_predicate_for name
+        define_predicate name
       end
 
       # @macro [attach] add_setting
       #   @!attribute [rw] $1
-      #   @!method $1=(value)
       #
       # @macro [attach] define_reader
       #   @!attribute [r] $1
@@ -90,13 +114,19 @@ module RSpec
       # `"spec"`). Allows you to just type `rspec` instead of `rspec spec` to
       # run all the examples in the `spec` directory.
       #
-      # Note: Other scripts invoking `rspec` indirectly will ignore this
-      # setting.
-      add_setting :default_path
+      # @note Other scripts invoking `rspec` indirectly will ignore this
+      #   setting.
+      # @return [String]
+      add_read_only_setting :default_path
+      def default_path=(path)
+        project_source_dirs << path
+        @default_path = path
+      end
 
       # @macro add_setting
       # Run examples over DRb (default: `false`). RSpec doesn't supply the DRb
       # server, but you can use tools like spork.
+      # @return [Boolean]
       add_setting :drb
 
       # @macro add_setting
@@ -109,6 +139,7 @@ module RSpec
 
       # Indicates if the DSL has been exposed off of modules and `main`.
       # Default: true
+      # @return [Boolean]
       def expose_dsl_globally?
         Core::DSL.exposed_globally?
       end
@@ -129,7 +160,7 @@ module RSpec
 
       # Determines where deprecation warnings are printed.
       # Defaults to `$stderr`.
-      # @return [IO, String] IO to write to or filename to write to
+      # @return [IO, String] IO or filename to write to
       define_reader :deprecation_stream
 
       # Determines where deprecation warnings are printed.
@@ -146,9 +177,60 @@ module RSpec
         end
       end
 
-      # @macro add_setting
-      # Clean up and exit after the first failure (default: `false`).
-      add_setting :fail_fast
+      # @macro define_reader
+      # The file path to use for persisting example statuses. Necessary for the
+      # `--only-failures` and `--next-failure` CLI options.
+      #
+      # @overload example_status_persistence_file_path
+      #   @return [String] the file path
+      # @overload example_status_persistence_file_path=(value)
+      #   @param value [String] the file path
+      define_reader :example_status_persistence_file_path
+
+      # Sets the file path to use for persisting example statuses. Necessary for the
+      # `--only-failures` and `--next-failure` CLI options.
+      def example_status_persistence_file_path=(value)
+        @example_status_persistence_file_path = value
+        clear_values_derived_from_example_status_persistence_file_path
+      end
+
+      # @macro define_reader
+      # Indicates if the `--only-failures` (or `--next-failure`) flag is being used.
+      define_reader :only_failures
+      alias_method :only_failures?, :only_failures
+
+      # @private
+      def only_failures_but_not_configured?
+        only_failures? && !example_status_persistence_file_path
+      end
+
+      # @macro define_reader
+      # If specified, indicates the number of failures required before cleaning
+      # up and exit (default: `nil`). Can also be `true` to fail and exit on first
+      # failure
+      define_reader :fail_fast
+
+      # @see fail_fast
+      def fail_fast=(value)
+        case value
+        when true, 'true'
+          @fail_fast = true
+        when false, 'false', 0
+          @fail_fast = false
+        when nil
+          @fail_fast = nil
+        else
+          @fail_fast = value.to_i
+
+          if value.to_i == 0
+            # TODO: in RSpec 4, consider raising an error here.
+            RSpec.warning "Cannot set `RSpec.configuration.fail_fast`" \
+              " to `#{value.inspect}`. Only `true`, `false`, `nil` and integers" \
+              " are valid values."
+            @fail_fast = true
+          end
+        end
+      end
 
       # @macro add_setting
       # Prints the formatter output of your suite without running any
@@ -157,23 +239,38 @@ module RSpec
 
       # @macro add_setting
       # The exit code to return if there are any failures (default: 1).
+      # @return [Integer]
       add_setting :failure_exit_code
 
+      # @macro add_setting
+      # The exit code to return if there are any errors outside examples (default: failure_exit_code)
+      # @return [Integer]
+      add_setting :error_exit_code
+
+      # @macro add_setting
+      # Whether or not to fail when there are no RSpec examples (default: false).
+      # @return [Boolean]
+      add_setting :fail_if_no_examples
+
       # @macro define_reader
-      # Indicates files configured to be required
+      # Indicates files configured to be required.
+      # @return [Array<String>]
       define_reader :requires
 
       # @macro define_reader
-      # Returns dirs that have been prepended to the load path by the `-I` command line option
+      # Returns dirs that have been prepended to the load path by the `-I`
+      # command line option.
+      # @return [Array<String>]
       define_reader :libs
 
       # @macro add_setting
       # Determines where RSpec will send its output.
       # Default: `$stdout`.
+      # @return [IO, String]
       define_reader :output_stream
 
-      # Set the output stream for reporter
-      # @attr value [IO] value for output, defaults to $stdout
+      # Set the output stream for reporter.
+      # @attr value [IO, String] IO to write to or filename to write to, defaults to $stdout
       def output_stream=(value)
         if @reporter && !value.equal?(@output_stream)
           warn "RSpec's reporter has already been initialized with " \
@@ -182,127 +279,270 @@ module RSpec
             "it to take effect. (Called from #{CallerFilter.first_non_rspec_line})"
         else
           @output_stream = value
+          output_wrapper.output = @output_stream
         end
       end
 
       # @macro define_reader
-      # Load files matching this pattern (default: `'**{,/*/**}/*_spec.rb'`)
+      # Load files matching this pattern (default: `'**{,/*/**}/*_spec.rb'`).
+      # @return [String]
       define_reader :pattern
 
-      # Set pattern to match files to load
+      # Set pattern to match files to load.
       # @attr value [String] the filename pattern to filter spec files by
       def pattern=(value)
         update_pattern_attr :pattern, value
       end
 
       # @macro define_reader
-      # Exclude files matching this pattern
+      # Exclude files matching this pattern.
+      # @return [String]
       define_reader :exclude_pattern
 
-      # Set pattern to match files to exclude
+      # Set pattern to match files to exclude.
       # @attr value [String] the filename pattern to exclude spec files by
       def exclude_pattern=(value)
         update_pattern_attr :exclude_pattern, value
       end
 
+      # @macro add_setting
+      # Specifies which directories contain the source code for your project.
+      # When a failure occurs, RSpec looks through the backtrace to find a
+      # a line of source to print. It first looks for a line coming from
+      # one of the project source directories so that, for example, it prints
+      # the expectation or assertion call rather than the source code from
+      # the expectation or assertion framework.
+      # @return [Array<String>]
+      add_setting :project_source_dirs
+
       # @macro add_setting
       # Report the times for the slowest examples (default: `false`).
       # Use this to specify the number of examples to include in the profile.
-      add_setting :profile_examples
+      # @return [Boolean]
+      attr_writer :profile_examples
+      define_predicate :profile_examples
 
       # @macro add_setting
-      # Run all examples if none match the configured filters (default: `false`).
+      # Run all examples if none match the configured filters
+      # (default: `false`).
+      # @deprecated Use {#filter_run_when_matching} instead for the specific
+      #   filters that you want to be ignored if none match.
       add_setting :run_all_when_everything_filtered
 
       # @macro add_setting
-      # Color to use to indicate success.
-      # @param color [Symbol] defaults to `:green` but can be set to one of the
-      #                       following: `[:black, :white, :red, :green, :yellow,
-      #                       :blue, :magenta, :cyan]`
+      # Color to use to indicate success.  Defaults to `:green` but can be set
+      # to one of the following: `[:black, :white, :red, :green, :yellow,
+      # :blue, :magenta, :cyan]`
+      # @return [Symbol]
       add_setting :success_color
 
       # @macro add_setting
-      # Color to use to print pending examples.
-      # @param color [Symbol] defaults to `:yellow` but can be set to one of the
-      #                       following: `[:black, :white, :red, :green, :yellow,
-      #                       :blue, :magenta, :cyan]`
+      # Color to use to print pending examples.  Defaults to `:yellow` but can
+      # be set to one of the following: `[:black, :white, :red, :green,
+      # :yellow, :blue, :magenta, :cyan]`
+      # @return [Symbol]
       add_setting :pending_color
 
       # @macro add_setting
-      # Color to use to indicate failure.
-      # @param color [Symbol] defaults to `:red` but can be set to one of the
-      #                       following: `[:black, :white, :red, :green, :yellow,
-      #                       :blue, :magenta, :cyan]`
+      # Color to use to indicate failure.  Defaults to `:red` but can be set to
+      # one of the following: `[:black, :white, :red, :green, :yellow, :blue,
+      # :magenta, :cyan]`
+      # @return [Symbol]
       add_setting :failure_color
 
       # @macro add_setting
-      # The default output color.
-      # @param color [Symbol] defaults to `:white` but can be set to one of the
-      #                       following:`[:black, :white, :red, :green, :yellow,
-      #                       :blue, :magenta, :cyan]`
+      # The default output color. Defaults to `:white` but can be set to one of
+      # the following: `[:black, :white, :red, :green, :yellow, :blue,
+      # :magenta, :cyan]`
+      # @return [Symbol]
       add_setting :default_color
 
       # @macro add_setting
-      # Color used when a pending example is fixed.
-      # @param color [Symbol] defaults to `:blue` but can be set to one of the
-      #                       following: `[:black, :white, :red, :green, :yellow,
-      #                       :blue, :magenta, :cyan]`
+      # Color used when a pending example is fixed. Defaults to `:blue` but can
+      # be set to one of the following: `[:black, :white, :red, :green,
+      # :yellow, :blue, :magenta, :cyan]`
+      # @return [Symbol]
       add_setting :fixed_color
 
       # @macro add_setting
-      # Color used to print details.
-      # @param color [Symbol] defaults to `:cyan` but can be set to one of the
-      #                       following: `[:black, :white, :red, :green, :yellow,
-      #                       :blue, :magenta, :cyan]`
+      # Color used to print details.  Defaults to `:cyan` but can be set to one
+      # of the following: `[:black, :white, :red, :green, :yellow, :blue,
+      # :magenta, :cyan]`
+      # @return [Symbol]
       add_setting :detail_color
 
-      # Deprecated. This config option was added in RSpec 2 to pave the way
-      # for this being the default behavior in RSpec 3. Now this option is
-      # a no-op.
+      # @macro add_setting
+      # Don't print filter info i.e. "Run options: include {:focus=>true}"
+      # (default `false`).
+      # return [Boolean]
+      add_setting :silence_filter_announcements
+
+      # @deprecated This config option was added in RSpec 2 to pave the way
+      #   for this being the default behavior in RSpec 3. Now this option is
+      #   a no-op.
       def treat_symbols_as_metadata_keys_with_true_values=(_value)
-        RSpec.deprecate("RSpec::Core::Configuration#treat_symbols_as_metadata_keys_with_true_values=",
-                        :message => "RSpec::Core::Configuration#treat_symbols_as_metadata_keys_with_true_values= " \
-                                    "is deprecated, it is now set to true as default and setting it to false has no effect.")
+        RSpec.deprecate(
+          "RSpec::Core::Configuration#treat_symbols_as_metadata_keys_with_true_values=",
+          :message => "RSpec::Core::Configuration#treat_symbols_as_metadata_keys_with_true_values= " \
+                      "is deprecated, it is now set to true as default and " \
+                      "setting it to false has no effect."
+        )
+      end
+
+      # @macro define_reader
+      # Configures how RSpec treats metadata passed as part of a shared example
+      # group definition. For example, given this shared example group definition:
+      #
+      #     RSpec.shared_context "uses DB", :db => true do
+      #       around(:example) do |ex|
+      #         MyORM.transaction(:rollback => true, &ex)
+      #       end
+      #     end
+      #
+      # ...there are two ways RSpec can treat the `:db => true` metadata, each
+      # of which has a corresponding config option:
+      #
+      # 1. `:trigger_inclusion`: this shared context will be implicitly included
+      #    in any groups (or examples) that have `:db => true` metadata.
+      # 2. `:apply_to_host_groups`: the metadata will be inherited by the metadata
+      #    hash of all host groups and examples.
+      #
+      # `:trigger_inclusion` is the legacy behavior from before RSpec 3.5 but should
+      # be considered deprecated. Instead, you can explicitly include a group with
+      # `include_context`:
+      #
+      #     RSpec.describe "My model" do
+      #       include_context "uses DB"
+      #     end
+      #
+      # ...or you can configure RSpec to include the context based on matching metadata
+      # using an API that mirrors configured module inclusion:
+      #
+      #     RSpec.configure do |rspec|
+      #       rspec.include_context "uses DB", :db => true
+      #     end
+      #
+      # `:apply_to_host_groups` is a new feature of RSpec 3.5 and will be the only
+      # supported behavior in RSpec 4.
+      #
+      # @overload shared_context_metadata_behavior
+      #   @return [:trigger_inclusion, :apply_to_host_groups] the configured behavior
+      # @overload shared_context_metadata_behavior=(value)
+      #   @param value [:trigger_inclusion, :apply_to_host_groups] sets the configured behavior
+      define_reader :shared_context_metadata_behavior
+      # @see shared_context_metadata_behavior
+      def shared_context_metadata_behavior=(value)
+        case value
+        when :trigger_inclusion, :apply_to_host_groups
+          @shared_context_metadata_behavior = value
+        else
+          raise ArgumentError, "Cannot set `RSpec.configuration." \
+            "shared_context_metadata_behavior` to `#{value.inspect}`. Only " \
+            "`:trigger_inclusion` and `:apply_to_host_groups` are valid values."
+        end
       end
 
-      # Record the start time of the spec suite to measure load time
+      # Record the start time of the spec suite to measure load time.
+      # return [Time]
       add_setting :start_time
 
+      # @macro add_setting
+      # Use threadsafe options where available.
+      # Currently this will place a mutex around memoized values such as let blocks.
+      # return [Boolean]
+      add_setting :threadsafe
+
+      # @macro add_setting
+      # Maximum count of failed source lines to display in the failure reports.
+      # (default `10`).
+      # return [Integer]
+      add_setting :max_displayed_failure_line_count
+
+      # Determines which bisect runner implementation gets used to run subsets
+      # of the suite during a bisection. Your choices are:
+      #
+      #   - `:shell`: Performs a spec run by shelling out, booting RSpec and your
+      #     application environment each time. This runner is the most widely
+      #     compatible runner, but is not as fast. On platforms that do not
+      #     support forking, this is the default.
+      #   - `:fork`: Pre-boots RSpec and your application environment in a parent
+      #     process, and then forks a child process for each spec run. This runner
+      #     tends to be significantly faster than the `:shell` runner but cannot
+      #     be used in some situations. On platforms that support forking, this
+      #     is the default. If you use this runner, you should ensure that all
+      #     of your one-time setup logic goes in a `before(:suite)` hook instead
+      #     of getting run at the top-level of a file loaded by `--require`.
+      #
+      # @note This option will only be used by `--bisect` if you set it in a file
+      #   loaded via `--require`.
+      #
+      # @return [Symbol]
+      attr_reader :bisect_runner
+      def bisect_runner=(value)
+        if @bisect_runner_class && value != @bisect_runner
+          raise "`config.bisect_runner = #{value.inspect}` can no longer take " \
+            "effect as the #{@bisect_runner.inspect} bisect runnner is already " \
+            "in use. This config setting must be set in a file loaded by a " \
+            "`--require` option (passed at the CLI or in a `.rspec` file) for " \
+            "it to have any effect."
+        end
+
+        @bisect_runner = value
+      end
+
       # @private
+      # @deprecated Use {#color_mode} = :on, instead of {#color} with {#tty}
       add_setting :tty
       # @private
-      add_setting :include_or_extend_modules
-      # @private
       attr_writer :files_to_run
       # @private
-      add_setting :expecting_with_rspec
+      attr_accessor :filter_manager, :world
       # @private
-      attr_accessor :filter_manager
+      attr_accessor :static_config_filter_manager
       # @private
-      attr_reader :backtrace_formatter, :ordering_manager
+      attr_reader :backtrace_formatter, :ordering_manager, :loaded_spec_files
 
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+
+      # Build an object to store runtime configuration options and set defaults
       def initialize
         # rubocop:disable Style/GlobalVars
         @start_time = $_rspec_core_load_started_at || ::RSpec::Core::Time.now
         # rubocop:enable Style/GlobalVars
         @expectation_frameworks = []
-        @include_or_extend_modules = []
+        @include_modules = FilterableItemRepository::QueryOptimized.new(:any?)
+        @extend_modules  = FilterableItemRepository::QueryOptimized.new(:any?)
+        @prepend_modules = FilterableItemRepository::QueryOptimized.new(:any?)
+
+        @bisect_runner = RSpec::Support::RubyFeatures.fork_supported? ? :fork : :shell
+        @bisect_runner_class = nil
+
+        @before_suite_hooks = []
+        @after_suite_hooks  = []
+
         @mock_framework = nil
         @files_or_directories_to_run = []
+        @loaded_spec_files = Set.new
         @color = false
+        @color_mode = :automatic
         @pattern = '**{,/*/**}/*_spec.rb'
         @exclude_pattern = ''
         @failure_exit_code = 1
+        @error_exit_code = nil # so it can be overridden by failure exit code
+        @fail_if_no_examples = false
         @spec_files_loaded = false
 
         @backtrace_formatter = BacktraceFormatter.new
 
         @default_path = 'spec'
+        @project_source_dirs = %w[ spec lib app ]
         @deprecation_stream = $stderr
         @output_stream = $stdout
         @reporter = nil
         @reporter_buffer = nil
         @filter_manager = FilterManager.new
+        @static_config_filter_manager = FilterManager.new
         @ordering_manager = Ordering::ConfigurationManager.new
         @preferred_options = {}
         @failure_color = :red
@@ -314,8 +554,16 @@ module RSpec
         @profile_examples = false
         @requires = []
         @libs = []
-        @derived_metadata_blocks = []
+        @derived_metadata_blocks = FilterableItemRepository::QueryOptimized.new(:any?)
+        @threadsafe = true
+        @max_displayed_failure_line_count = 10
+        @world = World::Null
+        @shared_context_metadata_behavior = :trigger_inclusion
+
+        define_built_in_hooks
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
 
       # @private
       #
@@ -323,27 +571,47 @@ module RSpec
       def force(hash)
         ordering_manager.force(hash)
         @preferred_options.merge!(hash)
+
+        return unless hash.key?(:example_status_persistence_file_path)
+        clear_values_derived_from_example_status_persistence_file_path
       end
 
       # @private
       def reset
         @spec_files_loaded = false
+        reset_reporter
+      end
+
+      # @private
+      def reset_reporter
         @reporter = nil
         @formatter_loader = nil
+        @output_wrapper = nil
+      end
+
+      # @private
+      def reset_filters
+        self.filter_manager = FilterManager.new
+        filter_manager.include_only(
+          Metadata.deep_hash_dup(static_config_filter_manager.inclusions.rules)
+        )
+        filter_manager.exclude_only(
+          Metadata.deep_hash_dup(static_config_filter_manager.exclusions.rules)
+        )
       end
 
       # @overload add_setting(name)
       # @overload add_setting(name, opts)
       # @option opts [Symbol] :default
       #
-      #   set a default value for the generated getter and predicate methods:
+      #   Set a default value for the generated getter and predicate methods:
       #
       #       add_setting(:foo, :default => "default value")
       #
       # @option opts [Symbol] :alias_with
       #
-      #   Use `:alias_with` to alias the setter, getter, and predicate to another
-      #   name, or names:
+      #   Use `:alias_with` to alias the setter, getter, and predicate to
+      #   another name, or names:
       #
       #       add_setting(:foo, :alias_with => :bar)
       #       add_setting(:foo, :alias_with => [:bar, :baz])
@@ -366,7 +634,7 @@ module RSpec
       #
       #     RSpec.configuration.foo=(value)
       #     RSpec.configuration.foo
-      #     RSpec.configuration.foo? # returns true if foo returns anything but nil or false
+      #     RSpec.configuration.foo? # Returns true if foo returns anything but nil or false.
       def add_setting(name, opts={})
         default = opts.delete(:default)
         (class << self; self; end).class_exec do
@@ -375,7 +643,8 @@ module RSpec
         __send__("#{name}=", default) if default
       end
 
-      # Returns the configured mock framework adapter module
+      # Returns the configured mock framework adapter module.
+      # @return [Symbol]
       def mock_framework
         if @mock_framework.nil?
           begin
@@ -387,7 +656,7 @@ module RSpec
         @mock_framework
       end
 
-      # Delegates to mock_framework=(framework)
+      # Delegates to mock_framework=(framework).
       def mock_framework=(framework)
         mock_with framework
       end
@@ -395,20 +664,21 @@ module RSpec
       # Regexps used to exclude lines from backtraces.
       #
       # Excludes lines from ruby (and jruby) source, installed gems, anything
-      # in any "bin" directory, and any of the rspec libs (outside gem
+      # in any "bin" directory, and any of the RSpec libs (outside gem
       # installs) by default.
       #
       # You can modify the list via the getter, or replace it with the setter.
       #
       # To override this behaviour and display a full backtrace, use
-      # `--backtrace`on the command line, in a `.rspec` file, or in the
+      # `--backtrace` on the command line, in a `.rspec` file, or in the
       # `rspec_options` attribute of RSpec's rake task.
+      # @return [Array<Regexp>]
       def backtrace_exclusion_patterns
         @backtrace_formatter.exclusion_patterns
       end
 
-      # Set regular expressions used to exclude lines in backtrace
-      # @param patterns [Regexp] set the backtrace exlusion pattern
+      # Set regular expressions used to exclude lines in backtrace.
+      # @param patterns [Array<Regexp>] set backtrace_formatter exlusion_patterns
       def backtrace_exclusion_patterns=(patterns)
         @backtrace_formatter.exclusion_patterns = patterns
       end
@@ -421,12 +691,13 @@ module RSpec
       # will be included.
       #
       # You can modify the list via the getter, or replace it with the setter.
+      # @return [Array<Regexp>]
       def backtrace_inclusion_patterns
         @backtrace_formatter.inclusion_patterns
       end
 
-      # Set regular expressions used to include lines in backtrace
-      # @attr patterns [Regexp] set backtrace_formatter inclusion_patterns
+      # Set regular expressions used to include lines in backtrace.
+      # @attr patterns [Array<Regexp>] set backtrace_formatter inclusion_patterns
       def backtrace_inclusion_patterns=(patterns)
         @backtrace_formatter.inclusion_patterns = patterns
       end
@@ -485,8 +756,8 @@ module RSpec
       #     teardown_mocks_for_rspec
       #       - called after verify_mocks_for_rspec (even if there are errors)
       #
-      # If the module responds to `configuration` and `mock_with` receives a block,
-      # it will yield the configuration object to the block e.g.
+      # If the module responds to `configuration` and `mock_with` receives a
+      # block, it will yield the configuration object to the block e.g.
       #
       #     config.mock_with OtherMockFrameworkAdapter do |mod_config|
       #       mod_config.custom_setting = true
@@ -507,7 +778,7 @@ module RSpec
           end
 
         new_name, old_name = [framework_module, @mock_framework].map do |mod|
-          mod.respond_to?(:framework_name) ?  mod.framework_name : :unnamed
+          mod.respond_to?(:framework_name) ? mod.framework_name : :unnamed
         end
 
         unless new_name == old_name
@@ -515,7 +786,8 @@ module RSpec
         end
 
         if block_given?
-          raise "#{framework_module} must respond to `configuration` so that mock_with can yield it." unless framework_module.respond_to?(:configuration)
+          raise "#{framework_module} must respond to `configuration` so that " \
+                "mock_with can yield it." unless framework_module.respond_to?(:configuration)
           yield framework_module.configuration
         end
 
@@ -534,7 +806,7 @@ module RSpec
         @expectation_frameworks
       end
 
-      # Delegates to expect_with(framework)
+      # Delegates to expect_with(framework).
       def expectation_framework=(framework)
         expect_with(framework)
       end
@@ -569,7 +841,13 @@ module RSpec
             framework
           when :rspec
             require 'rspec/expectations'
-            self.expecting_with_rspec = true
+
+            # Tag this exception class so our exception formatting logic knows
+            # that it satisfies the `MultipleExceptionError` interface.
+            ::RSpec::Expectations::MultipleExpectationsNotMetError.__send__(
+              :include, MultipleExceptionError::InterfaceTag
+            )
+
             ::RSpec::Matchers
           when :test_unit
             require 'rspec/core/test_unit_assertions_adapter'
@@ -587,55 +865,78 @@ module RSpec
         end
 
         if block_given?
-          raise "expect_with only accepts a block with a single argument. Call expect_with #{modules.length} times, once with each argument, instead." if modules.length > 1
-          raise "#{modules.first} must respond to `configuration` so that expect_with can yield it." unless modules.first.respond_to?(:configuration)
+          raise "expect_with only accepts a block with a single argument. " \
+                "Call expect_with #{modules.length} times, " \
+                "once with each argument, instead." if modules.length > 1
+          raise "#{modules.first} must respond to `configuration` so that " \
+                "expect_with can yield it." unless modules.first.respond_to?(:configuration)
           yield modules.first.configuration
         end
 
         @expectation_frameworks.push(*modules)
       end
 
-      # Check if full backtrace is enabled
+      # Check if full backtrace is enabled.
       # @return [Boolean] is full backtrace enabled
       def full_backtrace?
         @backtrace_formatter.full_backtrace?
       end
 
-      # Toggle full backtrace
+      # Toggle full backtrace.
       # @attr true_or_false [Boolean] toggle full backtrace display
       def full_backtrace=(true_or_false)
         @backtrace_formatter.full_backtrace = true_or_false
       end
 
-      # Returns the configuration option for color, but should not
-      # be used to check if color is supported.
+      # Enables color output if the output is a TTY.  As of RSpec 3.6, this is
+      # the default behavior and this option is retained only for backwards
+      # compatibility.
       #
+      # @deprecated No longer recommended because of complex behavior. Instead,
+      #   rely on the fact that TTYs will display color by default, or set
+      #   {#color_mode} to :on to display color on a non-TTY output.
+      # @see color_mode
       # @see color_enabled?
       # @return [Boolean]
       def color
-        value_for(:color, @color)
+        value_for(:color) { @color }
+      end
+
+      # The mode for determining whether to display output in color. One of:
+      #
+      # - :automatic - the output will be in color if the output is a TTY (the
+      #   default)
+      # - :on - the output will be in color, whether or not the output is a TTY
+      # - :off - the output will not be in color
+      #
+      # @see color_enabled?
+      # @return [Boolean]
+      def color_mode
+        value_for(:color_mode) { @color_mode }
       end
 
-      # Check if color is enabled for a particular output
+      # Check if color is enabled for a particular output.
       # @param output [IO] an output stream to use, defaults to the current
       #        `output_stream`
       # @return [Boolean]
       def color_enabled?(output=output_stream)
-        output_to_tty?(output) && color
+        case color_mode
+        when :on then true
+        when :off then false
+        else # automatic
+          output_to_tty?(output) || (color && tty?)
+        end
       end
 
-      # Toggle output color
-      # @attr true_or_false [Boolean] toggle color enabled
-      def color=(true_or_false)
-        return unless true_or_false
+      # Set the color mode.
+      attr_writer :color_mode
 
-        if RSpec.world.windows_os? && !ENV['ANSICON']
-          RSpec.warning "You must use ANSICON 1.31 or later (http://adoxa.3eeweb.com/ansicon/) to use colour on Windows"
-          @color = false
-        else
-          @color = true
-        end
-      end
+      # Toggle output color.
+      #
+      # @deprecated No longer recommended because of complex behavior. Instead,
+      #   rely on the fact that TTYs will display color by default, or set
+      #   {:color_mode} to :on to display color on a non-TTY output.
+      attr_writer :color
 
       # @private
       def libs=(libs)
@@ -657,19 +958,22 @@ module RSpec
       end
 
       # @overload add_formatter(formatter)
+      # @overload add_formatter(formatter, output)
       #
-      # Adds a formatter to the formatters collection. `formatter` can be a
-      # string representing any of the built-in formatters (see
-      # `built_in_formatter`), or a custom formatter class.
+      # @param formatter [Class, String, Object] formatter to use. Can be any of the
+      #   string values supported from the CLI (`p`/`progress`,
+      #   `d`/`doc`/`documentation`, `h`/`html`, or `j`/`json`), any
+      #   class that implements the formatter protocol and has registered
+      #   itself with RSpec as a formatter, or a formatter instance.
+      # @param output [String, IO] where the formatter will write its output.
+      #   Can be an IO object or a string path to a file. If not provided,
+      #   the configured `output_stream` (`$stdout`, by default) will be used.
       #
-      # ### Note
+      # Adds a formatter to the set RSpec will use for this run.
       #
-      # For internal purposes, `add_formatter` also accepts the name of a class
-      # and paths to use for output streams, but you should consider that a
-      # private api that may change at any time without notice.
-      def add_formatter(formatter_to_use, *paths)
-        paths << output_stream if paths.empty?
-        formatter_loader.add formatter_to_use, *paths
+      # @see RSpec::Core::Formatters::Protocol
+      def add_formatter(formatter, output=output_wrapper)
+        formatter_loader.add(formatter, output)
       end
       alias_method :formatter=, :add_formatter
 
@@ -727,14 +1031,14 @@ module RSpec
         end
       end
 
-      # @private
+      # @return [RSpec::Core::Reporter] the currently configured reporter
       def reporter
         # @reporter_buffer should only ever be set in this method to cover
         # initialization of @reporter.
         @reporter_buffer || @reporter ||=
           begin
             @reporter_buffer = DeprecationReporterBuffer.new
-            formatter_loader.setup_default output_stream, deprecation_stream
+            formatter_loader.prepare_default output_wrapper, deprecation_stream
             @reporter_buffer.play_onto(formatter_loader.reporter)
             @reporter_buffer = nil
             formatter_loader.reporter
@@ -743,10 +1047,10 @@ module RSpec
 
       # @api private
       #
-      # Defaults `profile_examples` to 10 examples when `@profile_examples` is `true`.
-      #
+      # Defaults `profile_examples` to 10 examples when `@profile_examples` is
+      # `true`.
       def profile_examples
-        profile = value_for(:profile_examples, @profile_examples)
+        profile = value_for(:profile_examples) { @profile_examples }
         if profile && !profile.is_a?(Integer)
           10
         else
@@ -757,17 +1061,66 @@ module RSpec
       # @private
       def files_or_directories_to_run=(*files)
         files = files.flatten
-        files << default_path if (command == 'rspec' || Runner.running_in_drb?) && default_path && files.empty?
+
+        if (command == 'rspec' || Runner.running_in_drb?) && default_path && files.empty?
+          files << default_path
+        end
+
         @files_or_directories_to_run = files
         @files_to_run = nil
       end
 
-      # The spec files RSpec will run
+      # The spec files RSpec will run.
       # @return [Array] specified files about to run
       def files_to_run
         @files_to_run ||= get_files_to_run(@files_or_directories_to_run)
       end
 
+      # @private
+      def last_run_statuses
+        @last_run_statuses ||= Hash.new(UNKNOWN_STATUS).tap do |statuses|
+          if (path = example_status_persistence_file_path)
+            begin
+              ExampleStatusPersister.load_from(path).inject(statuses) do |hash, example|
+                status = example[:status]
+                status = UNKNOWN_STATUS unless VALID_STATUSES.include?(status)
+                hash[example.fetch(:example_id)] = status
+                hash
+              end
+            rescue SystemCallError => e
+              RSpec.warning "Could not read from #{path.inspect} (configured as " \
+                            "`config.example_status_persistence_file_path`) due " \
+                            "to a system error: #{e.inspect}. Please check that " \
+                            "the config option is set to an accessible, valid " \
+                            "file path", :call_site => nil
+            end
+          end
+        end
+      end
+
+      # @private
+      UNKNOWN_STATUS = "unknown".freeze
+
+      # @private
+      FAILED_STATUS = "failed".freeze
+
+      # @private
+      PASSED_STATUS = "passed".freeze
+
+      # @private
+      PENDING_STATUS = "pending".freeze
+
+      # @private
+      VALID_STATUSES = [UNKNOWN_STATUS, FAILED_STATUS, PASSED_STATUS, PENDING_STATUS]
+
+      # @private
+      def spec_files_with_failures
+        @spec_files_with_failures ||= last_run_statuses.inject(Set.new) do |files, (id, status)|
+          files << Example.parse_id(id).first if status == FAILED_STATUS
+          files
+        end.to_a
+      end
+
       # Creates a method that delegates to `example` including the submitted
       # `args`. Used internally to add variants of `example` like `pending`:
       # @param name [String] example name alias
@@ -776,8 +1129,8 @@ module RSpec
       # @note The specific example alias below (`pending`) is already
       #   defined for you.
       # @note Use with caution. This extends the language used in your
-      #   specs, but does not add any additional documentation.  We use this
-      #   in rspec to define methods like `focus` and `xit`, but we also add
+      #   specs, but does not add any additional documentation. We use this
+      #   in RSpec to define methods like `focus` and `xit`, but we also add
       #   docs for those methods.
       #
       # @example
@@ -787,7 +1140,7 @@ module RSpec
       #
       #   # This lets you do this:
       #
-      #   describe Thing do
+      #   RSpec.describe Thing do
       #     pending "does something" do
       #       thing = Thing.new
       #     end
@@ -795,7 +1148,7 @@ module RSpec
       #
       #   # ... which is the equivalent of
       #
-      #   describe Thing do
+      #   RSpec.describe Thing do
       #     it "does something", :pending => true do
       #       thing = Thing.new
       #     end
@@ -848,7 +1201,7 @@ module RSpec
       #
       #   # allows the user to include a shared example group like:
       #
-      #   describe Entity do
+      #   RSpec.describe Entity do
       #     it_has_behavior 'sortability' do
       #       let(:sortable) { Entity.new }
       #     end
@@ -860,8 +1213,8 @@ module RSpec
       #   #     ...sortability examples here
       #
       # @note Use with caution. This extends the language used in your
-      #   specs, but does not add any additional documentation.  We use this
-      #   in rspec to define `it_should_behave_like` (for backward
+      #   specs, but does not add any additional documentation. We use this
+      #   in RSpec to define `it_should_behave_like` (for backward
       #   compatibility), but we also add docs for that method.
       def alias_it_behaves_like_to(new_name, report_label='')
         RSpec::Core::ExampleGroup.define_nested_shared_group_method(new_name, report_label)
@@ -878,32 +1231,48 @@ module RSpec
       # or config files (e.g. `.rspec`).
       #
       # @example
-      #     # given this declaration
+      #     # Given this declaration.
       #     describe "something", :foo => 'bar' do
       #       # ...
       #     end
       #
-      #     # any of the following will include that group
+      #     # Any of the following will include that group.
       #     config.filter_run_including :foo => 'bar'
       #     config.filter_run_including :foo => /^ba/
       #     config.filter_run_including :foo => lambda {|v| v == 'bar'}
       #     config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'}
       #
-      #     # given a proc with an arity of 1, the lambda is passed the value related to the key, e.g.
+      #     # Given a proc with an arity of 1, the lambda is passed the value
+      #     # related to the key, e.g.
       #     config.filter_run_including :foo => lambda {|v| v == 'bar'}
       #
-      #     # given a proc with an arity of 2, the lambda is passed the value related to the key,
-      #     # and the metadata itself e.g.
+      #     # Given a proc with an arity of 2, the lambda is passed the value
+      #     # related to the key, and the metadata itself e.g.
       #     config.filter_run_including :foo => lambda {|v,m| m[:foo] == 'bar'}
       #
       #     filter_run_including :foo # same as filter_run_including :foo => true
       def filter_run_including(*args)
         meta = Metadata.build_hash_from(args, :warn_about_example_group_filtering)
         filter_manager.include_with_low_priority meta
+        static_config_filter_manager.include_with_low_priority Metadata.deep_hash_dup(meta)
       end
-
       alias_method :filter_run, :filter_run_including
 
+      # Applies the provided filter only if any of examples match, in constrast
+      # to {#filter_run}, which always applies even if no examples match, in
+      # which case no examples will be run. This allows you to leave configured
+      # filters in place that are intended only for temporary use. The most common
+      # example is focus filtering: `config.filter_run_when_matching :focus`.
+      # With that configured, you can temporarily focus an example or group
+      # by tagging it with `:focus` metadata, or prefixing it with an `f`
+      # (as in `fdescribe`, `fcontext` and `fit`) since those are aliases for
+      # `describe`/`context`/`it` with `:focus` metadata.
+      def filter_run_when_matching(*args)
+        when_first_matching_example_defined(*args) do
+          filter_run(*args)
+        end
+      end
+
       # Clears and reassigns the `inclusion_filter`. Set to `nil` if you don't
       # want any inclusion filter at all.
       #
@@ -936,28 +1305,30 @@ module RSpec
       # or config files (e.g. `.rspec`).
       #
       # @example
-      #     # given this declaration
+      #     # Given this declaration.
       #     describe "something", :foo => 'bar' do
       #       # ...
       #     end
       #
-      #     # any of the following will exclude that group
+      #     # Any of the following will exclude that group.
       #     config.filter_run_excluding :foo => 'bar'
       #     config.filter_run_excluding :foo => /^ba/
       #     config.filter_run_excluding :foo => lambda {|v| v == 'bar'}
       #     config.filter_run_excluding :foo => lambda {|v,m| m[:foo] == 'bar'}
       #
-      #     # given a proc with an arity of 1, the lambda is passed the value related to the key, e.g.
+      #     # Given a proc with an arity of 1, the lambda is passed the value
+      #     # related to the key, e.g.
       #     config.filter_run_excluding :foo => lambda {|v| v == 'bar'}
       #
-      #     # given a proc with an arity of 2, the lambda is passed the value related to the key,
-      #     # and the metadata itself e.g.
+      #     # Given a proc with an arity of 2, the lambda is passed the value
+      #     # related to the key, and the metadata itself e.g.
       #     config.filter_run_excluding :foo => lambda {|v,m| m[:foo] == 'bar'}
       #
       #     filter_run_excluding :foo # same as filter_run_excluding :foo => true
       def filter_run_excluding(*args)
         meta = Metadata.build_hash_from(args, :warn_about_example_group_filtering)
         filter_manager.exclude_with_low_priority meta
+        static_config_filter_manager.exclude_with_low_priority Metadata.deep_hash_dup(meta)
       end
 
       # Clears and reassigns the `exclusion_filter`. Set to `nil` if you don't
@@ -979,8 +1350,8 @@ module RSpec
       end
 
       # Tells RSpec to include `mod` in example groups. Methods defined in
-      # `mod` are exposed to examples (not example groups).  Use `filters` to
-      # constrain the groups in which to include the module.
+      # `mod` are exposed to examples (not example groups). Use `filters` to
+      # constrain the groups or examples in which to include the module.
       #
       # @example
       #
@@ -990,6 +1361,12 @@ module RSpec
       #       end
       #     end
       #
+      #     module PreferencesHelpers
+      #       def preferences(user, preferences = {})
+      #         # ...
+      #       end
+      #     end
+      #
       #     module UserHelpers
       #       def users(username)
       #         # ...
@@ -997,26 +1374,87 @@ module RSpec
       #     end
       #
       #     RSpec.configure do |config|
-      #       config.include(UserHelpers) # included in all modules
+      #       config.include(UserHelpers) # included in all groups
+      #
+      #       # included in examples with `:preferences` metadata
+      #       config.include(PreferenceHelpers, :preferences)
+      #
+      #       # included in examples with `:type => :request` metadata
       #       config.include(AuthenticationHelpers, :type => :request)
       #     end
       #
-      #     describe "edit profile", :type => :request do
+      #     describe "edit profile", :preferences, :type => :request do
       #       it "can be viewed by owning user" do
-      #         login_as users(:jdoe)
+      #         login_as preferences(users(:jdoe), :lang => 'es')
       #         get "/profiles/jdoe"
       #         assert_select ".username", :text => 'jdoe'
       #       end
       #     end
       #
+      # @note Filtered module inclusions can also be applied to
+      #   individual examples that have matching metadata. Just like
+      #   Ruby's object model is that every object has a singleton class
+      #   which has only a single instance, RSpec's model is that every
+      #   example has a singleton example group containing just the one
+      #   example.
+      #
+      # @see #include_context
       # @see #extend
+      # @see #prepend
       def include(mod, *filters)
-        meta = Metadata.build_hash_from(filters, :warn_about_example_group_filtering)
-        include_or_extend_modules << [:include, mod, meta]
+        define_mixed_in_module(mod, filters, @include_modules, :include) do |group|
+          safe_include(mod, group)
+        end
+      end
+
+      # Tells RSpec to include the named shared example group in example groups.
+      # Use `filters` to constrain the groups or examples in which to include
+      # the example group.
+      #
+      # @example
+      #
+      #     RSpec.shared_context "example admin user" do
+      #       let(:admin_user) { create_user(:admin) }
+      #     end
+      #
+      #     RSpec.shared_context "example guest user" do
+      #       let(:guest_user) { create_user(:guest) }
+      #     end
+      #
+      #     RSpec.configure do |config|
+      #       config.include_context "example guest user", :type => :request
+      #       config.include_context "example admin user", :admin, :type => :request
+      #     end
+      #
+      #     RSpec.describe "The admin page", :type => :request do
+      #       it "can be viewed by admins", :admin do
+      #         login_with admin_user
+      #         get "/admin"
+      #         expect(response).to be_ok
+      #       end
+      #
+      #       it "cannot be viewed by guests" do
+      #         login_with guest_user
+      #         get "/admin"
+      #         expect(response).to be_forbidden
+      #       end
+      #     end
+      #
+      # @note Filtered context inclusions can also be applied to
+      #   individual examples that have matching metadata. Just like
+      #   Ruby's object model is that every object has a singleton class
+      #   which has only a single instance, RSpec's model is that every
+      #   example has a singleton example group containing just the one
+      #   example.
+      #
+      # @see #include
+      def include_context(shared_group_name, *filters)
+        shared_module = world.shared_example_group_registry.find([:main], shared_group_name)
+        include shared_module, *filters
       end
 
-      # Tells RSpec to extend example groups with `mod`.  Methods defined in
-      # `mod` are exposed to example groups (not examples).  Use `filters` to
+      # Tells RSpec to extend example groups with `mod`. Methods defined in
+      # `mod` are exposed to example groups (not examples). Use `filters` to
       # constrain the groups to extend.
       #
       # Similar to `include`, but behavior is added to example groups, which
@@ -1031,12 +1469,20 @@ module RSpec
       #       end
       #     end
       #
+      #     module PermissionHelpers
+      #       def define_permissions
+      #         # ...
+      #       end
+      #     end
+      #
       #     RSpec.configure do |config|
       #       config.extend(UiHelpers, :type => :request)
+      #       config.extend(PermissionHelpers, :with_permissions, :type => :request)
       #     end
       #
-      #     describe "edit profile", :type => :request do
+      #     describe "edit profile", :with_permissions, :type => :request do
       #       run_in_browser
+      #       define_permissions
       #
       #       it "does stuff in the client" do
       #         # ...
@@ -1044,46 +1490,100 @@ module RSpec
       #     end
       #
       # @see #include
+      # @see #prepend
       def extend(mod, *filters)
-        meta = Metadata.build_hash_from(filters, :warn_about_example_group_filtering)
-        include_or_extend_modules << [:extend, mod, meta]
+        define_mixed_in_module(mod, filters, @extend_modules, :extend) do |group|
+          safe_extend(mod, group)
+        end
+      end
+
+      if RSpec::Support::RubyFeatures.module_prepends_supported?
+        # Tells RSpec to prepend example groups with `mod`. Methods defined in
+        # `mod` are exposed to examples (not example groups). Use `filters` to
+        # constrain the groups in which to prepend the module.
+        #
+        # Similar to `include`, but module is included before the example group's class
+        # in the ancestor chain.
+        #
+        # @example
+        #
+        #     module OverrideMod
+        #       def override_me
+        #         "overridden"
+        #       end
+        #     end
+        #
+        #     RSpec.configure do |config|
+        #       config.prepend(OverrideMod, :method => :prepend)
+        #     end
+        #
+        #     describe "overriding example's class", :method => :prepend do
+        #       it "finds the user" do
+        #         self.class.class_eval do
+        #           def override_me
+        #           end
+        #         end
+        #         override_me # => "overridden"
+        #         # ...
+        #       end
+        #     end
+        #
+        # @see #include
+        # @see #extend
+        def prepend(mod, *filters)
+          define_mixed_in_module(mod, filters, @prepend_modules, :prepend) do |group|
+            safe_prepend(mod, group)
+          end
+        end
       end
 
       # @private
       #
-      # Used internally to extend a group with modules using `include` and/or
+      # Used internally to extend a group with modules using `include`, `prepend` and/or
       # `extend`.
       def configure_group(group)
-        include_or_extend_modules.each do |include_or_extend, mod, filters|
-          next unless filters.empty? || group.any_apply?(filters)
-          __send__("safe_#{include_or_extend}", mod, group)
-        end
+        group.hooks.register_globals(group, hooks)
+
+        configure_group_with group, @include_modules, :safe_include
+        configure_group_with group, @extend_modules,  :safe_extend
+        configure_group_with group, @prepend_modules, :safe_prepend
       end
 
       # @private
-      def safe_include(mod, host)
-        host.__send__(:include, mod) unless host < mod
+      #
+      # Used internally to extend the singleton class of a single example's
+      # example group instance with modules using `include` and/or `extend`.
+      def configure_example(example, example_hooks)
+        example_hooks.register_global_singleton_context_hooks(example, hooks)
+        singleton_group = example.example_group_instance.singleton_class
+
+        # We replace the metadata so that SharedExampleGroupModule#included
+        # has access to the example's metadata[:location].
+        singleton_group.with_replaced_metadata(example.metadata) do
+          modules = @include_modules.items_for(example.metadata)
+          modules.each do |mod|
+            safe_include(mod, example.example_group_instance.singleton_class)
+          end
+
+          MemoizedHelpers.define_helpers_on(singleton_group) unless modules.empty?
+        end
       end
 
       # @private
       def requires=(paths)
         directories = ['lib', default_path].select { |p| File.directory? p }
         RSpec::Core::RubyProject.add_to_load_path(*directories)
-        paths.each { |path| require path }
+        paths.each { |path| load_file_handling_errors(:require, path) }
         @requires += paths
       end
 
       # @private
-      if RUBY_VERSION.to_f >= 1.9
-        # @private
-        def safe_extend(mod, host)
-          host.extend(mod) unless host.singleton_class < mod
-        end
-      else
-        # @private
-        def safe_extend(mod, host)
-          host.extend(mod) unless (class << host; self; end).included_modules.include?(mod)
+      def in_project_source_dir_regex
+        regexes = project_source_dirs.map do |dir|
+          /\A#{Regexp.escape(File.expand_path(dir))}\//
         end
+
+        Regexp.union(regexes)
       end
 
       # @private
@@ -1102,7 +1602,22 @@ module RSpec
 
       # @private
       def load_spec_files
-        files_to_run.uniq.each { |f| load File.expand_path(f) }
+        # Note which spec files world is already aware of.
+        # This is generally only needed for when the user runs
+        # `ruby path/to/spec.rb` (and loads `rspec/autorun`) --
+        # in that case, the spec file was loaded by `ruby` and
+        # isn't loaded by us here so we only know about it because
+        # of an example group being registered in it.
+        world.registered_example_group_files.each do |f|
+          loaded_spec_files << f # the registered files are already expended absolute paths
+        end
+
+        files_to_run.uniq.each do |f|
+          file = File.expand_path(f)
+          load_file_handling_errors(:load, file)
+          loaded_spec_files << file
+        end
+
         @spec_files_loaded = true
       end
 
@@ -1112,7 +1627,8 @@ module RSpec
       # Formats the docstring output using the block provided.
       #
       # @example
-      #   # This will strip the descriptions of both examples and example groups.
+      #   # This will strip the descriptions of both examples and example
+      #   # groups.
       #   RSpec.configure do |config|
       #     config.format_docstrings { |s| s.strip }
       #   end
@@ -1126,8 +1642,6 @@ module RSpec
       end
 
       # @private
-      # @macro [attach] delegate_to_ordering_manager
-      #   @!method $1
       def self.delegate_to_ordering_manager(*methods)
         methods.each do |method|
           define_method method do |*args, &block|
@@ -1136,12 +1650,12 @@ module RSpec
         end
       end
 
-      # @macro delegate_to_ordering_manager
+      # @!method seed=(value)
       #
       # Sets the seed value and sets the default global ordering to random.
       delegate_to_ordering_manager :seed=
 
-      # @macro delegate_to_ordering_manager
+      # @!method seed
       # Seed for random ordering (default: generated randomly each run).
       #
       # When you run specs with `--order random`, RSpec generates a random seed
@@ -1155,20 +1669,28 @@ module RSpec
       # don't accidentally leave the seed encoded.
       delegate_to_ordering_manager :seed
 
-      # @macro delegate_to_ordering_manager
+      # @!method order=(value)
       #
-      # Sets the default global order and, if order is `'rand:<seed>'`, also sets the seed.
+      # Sets the default global ordering strategy. By default this can be one
+      # of `:defined`, `:random`, but is customizable through the
+      # `register_ordering` API. If order is set to `'rand:<seed>'`,
+      # the seed will also be set.
+      #
+      # @see #register_ordering
       delegate_to_ordering_manager :order=
 
-      # @macro delegate_to_ordering_manager
+      # @!method register_ordering(name)
+      #
       # Registers a named ordering strategy that can later be
       # used to order an example group's subgroups by adding
       # `:order => <name>` metadata to the example group.
       #
       # @param name [Symbol] The name of the ordering.
       # @yield Block that will order the given examples or example groups
-      # @yieldparam list [Array<RSpec::Core::Example>, Array<RSpec::Core::ExampleGroup>] The examples or groups to order
-      # @yieldreturn [Array<RSpec::Core::Example>, Array<RSpec::Core::ExampleGroup>] The re-ordered examples or groups
+      # @yieldparam list [Array<RSpec::Core::Example>,
+      #   Array<RSpec::Core::ExampleGroup>] The examples or groups to order
+      # @yieldreturn [Array<RSpec::Core::Example>,
+      #   Array<RSpec::Core::ExampleGroup>] The re-ordered examples or groups
       #
       # @example
       #   RSpec.configure do |rspec|
@@ -1177,19 +1699,38 @@ module RSpec
       #     end
       #   end
       #
-      #   describe MyClass, :order => :reverse do
+      #   RSpec.describe 'MyClass', :order => :reverse do
       #     # ...
       #   end
       #
       # @note Pass the symbol `:global` to set the ordering strategy that
       #   will be used to order the top-level example groups and any example
       #   groups that do not have declared `:order` metadata.
+      #
+      # @example
+      #   RSpec.configure do |rspec|
+      #     rspec.register_ordering :global do |examples|
+      #       acceptance, other = examples.partition do |example|
+      #         example.metadata[:type] == :acceptance
+      #       end
+      #       other + acceptance
+      #     end
+      #   end
+      #
+      #   RSpec.describe 'MyClass', :type => :acceptance do
+      #     # will run last
+      #   end
+      #
+      #   RSpec.describe 'MyClass' do
+      #     # will run first
+      #   end
+      #
       delegate_to_ordering_manager :register_ordering
 
       # @private
       delegate_to_ordering_manager :seed_used?, :ordering_registry
 
-      # Set Ruby warnings on or off
+      # Set Ruby warnings on or off.
       def warnings=(value)
         $VERBOSE = !!value
       end
@@ -1199,6 +1740,25 @@ module RSpec
         $VERBOSE
       end
 
+      # @private
+      RAISE_ERROR_WARNING_NOTIFIER = lambda { |message| raise message }
+
+      # Turns warnings into errors. This can be useful when
+      # you want RSpec to run in a 'strict' no warning situation.
+      #
+      # @example
+      #
+      #   RSpec.configure do |rspec|
+      #     rspec.raise_on_warning = true
+      #   end
+      def raise_on_warning=(value)
+        if value
+          RSpec::Support.warning_notifier = RAISE_ERROR_WARNING_NOTIFIER
+        else
+          RSpec::Support.warning_notifier = RSpec::Support::DEFAULT_WARNING_NOTIFIER
+        end
+      end
+
       # Exposes the current running example via the named
       # helper method. RSpec 2.x exposed this via `example`,
       # but in RSpec 3.0, the example is instead exposed via
@@ -1215,7 +1775,7 @@ module RSpec
       #     rspec.expose_current_running_example_as :example
       #   end
       #
-      #   describe MyClass do
+      #   RSpec.describe MyClass do
       #     before do
       #       # `example` can be used here because of the above config.
       #       do_something if example.metadata[:type] == "foo"
@@ -1252,7 +1812,7 @@ module RSpec
       # `shared_examples_for`, etc) onto `main` and `Module`, instead
       # requiring you to prefix these methods with `RSpec.`. It enables
       # expect-only syntax for rspec-mocks and rspec-expectations. It
-      # simply disables monkey patching on whatever pieces of rspec
+      # simply disables monkey patching on whatever pieces of RSpec
       # the user is using.
       #
       # @note It configures rspec-mocks and rspec-expectations only
@@ -1265,7 +1825,7 @@ module RSpec
       #
       # @example
       #
-      #   # It disables all monkey patching
+      #   # It disables all monkey patching.
       #   RSpec.configure do |config|
       #     config.disable_monkey_patching!
       #   end
@@ -1279,7 +1839,7 @@ module RSpec
       #       mocks.patch_marshal_to_support_partial_doubles = false
       #     end
       #
-      #     config.mock_with :rspec do |expectations|
+      #     config.expect_with :rspec do |expectations|
       #       expectations.syntax = :expect
       #     end
       #   end
@@ -1295,43 +1855,333 @@ module RSpec
 
       # Defines a callback that can assign derived metadata values.
       #
-      # @param filters [Array<Symbol>, Hash] metadata filters that determine which example
-      #   or group metadata hashes the callback will be triggered for. If none are given,
-      #   the callback will be run against the metadata hashes of all groups and examples.
-      # @yieldparam metadata [Hash] original metadata hash from an example or group. Mutate this in
-      #   your block as needed.
+      # @param filters [Array<Symbol>, Hash] metadata filters that determine
+      #   which example or group metadata hashes the callback will be triggered
+      #   for. If none are given, the callback will be run against the metadata
+      #   hashes of all groups and examples.
+      # @yieldparam metadata [Hash] original metadata hash from an example or
+      #   group. Mutate this in your block as needed.
       #
       # @example
       #   RSpec.configure do |config|
-      #     # Tag all groups and examples in the spec/unit directory with :type => :unit
+      #     # Tag all groups and examples in the spec/unit directory with
+      #     # :type => :unit
       #     config.define_derived_metadata(:file_path => %r{/spec/unit/}) do |metadata|
       #       metadata[:type] = :unit
       #     end
       #   end
       def define_derived_metadata(*filters, &block)
         meta = Metadata.build_hash_from(filters, :warn_about_example_group_filtering)
-        @derived_metadata_blocks << [meta, block]
+        @derived_metadata_blocks.append(block, meta)
+      end
+
+      # Defines a callback that runs after the first example with matching
+      # metadata is defined. If no examples are defined with matching metadata,
+      # it will not get called at all.
+      #
+      # This can be used to ensure some setup is performed (such as bootstrapping
+      # a DB or loading a specific file that adds significantly to the boot time)
+      # if needed (as indicated by the presence of an example with matching metadata)
+      # but avoided otherwise.
+      #
+      # @example
+      #   RSpec.configure do |config|
+      #     config.when_first_matching_example_defined(:db) do
+      #       # Load a support file that does some heavyweight setup,
+      #       # including bootstrapping the DB, but only if we have loaded
+      #       # any examples tagged with `:db`.
+      #       require 'support/db'
+      #     end
+      #   end
+      def when_first_matching_example_defined(*filters)
+        specified_meta = Metadata.build_hash_from(filters, :warn_about_example_group_filtering)
+
+        callback = lambda do |example_or_group_meta|
+          # Example groups do not have `:example_group` metadata
+          # (instead they have `:parent_example_group` metadata).
+          return unless example_or_group_meta.key?(:example_group)
+
+          # Ensure the callback only fires once.
+          @derived_metadata_blocks.delete(callback, specified_meta)
+
+          yield
+        end
+
+        @derived_metadata_blocks.append(callback, specified_meta)
       end
 
       # @private
       def apply_derived_metadata_to(metadata)
-        @derived_metadata_blocks.each do |filter, block|
-          block.call(metadata) if filter.empty? || MetadataFilter.any_apply?(filter, metadata)
+        already_run_blocks = Set.new
+
+        # We loop and attempt to re-apply metadata blocks to support cascades
+        # (e.g. where a derived bit of metadata triggers the application of
+        # another piece of derived metadata, etc)
+        #
+        # We limit our looping to 200 times as a way to detect infinitely recursing derived metadata blocks.
+        # It's hard to imagine a valid use case for a derived metadata cascade greater than 200 iterations.
+        200.times do
+          return if @derived_metadata_blocks.items_for(metadata).all? do |block|
+            already_run_blocks.include?(block).tap do |skip_block|
+              block.call(metadata) unless skip_block
+              already_run_blocks << block
+            end
+          end
+        end
+
+        # If we got here, then `@derived_metadata_blocks.items_for(metadata).all?` never returned
+        # `true` above and we treat this as an attempt to recurse infinitely. It's better to fail
+        # with a clear # error than hang indefinitely, which is what would happen if we didn't limit
+        # the looping above.
+        raise SystemStackError, "Attempted to recursively derive metadata indefinitely."
+      end
+
+      # Defines a `before` hook. See {Hooks#before} for full docs.
+      #
+      # This method differs from {Hooks#before} in only one way: it supports
+      # the `:suite` scope. Hooks with the `:suite` scope will be run once before
+      # the first example of the entire suite is executed. Conditions passed along
+      # with `:suite` are effectively ignored.
+      #
+      # @see #prepend_before
+      # @see #after
+      # @see #append_after
+      def before(scope=nil, *meta, &block)
+        handle_suite_hook(scope, meta) do
+          @before_suite_hooks << Hooks::BeforeHook.new(block, {})
+        end || begin
+          # defeat Ruby 2.5 lazy proc allocation to ensure
+          # the methods below are passed the same proc instances
+          # so `Hook` equality is preserved. For more info, see:
+          # https://bugs.ruby-lang.org/issues/14045#note-5
+          block.__id__
+
+          add_hook_to_existing_matching_groups(meta, scope) { |g| g.before(scope, *meta, &block) }
+          super(scope, *meta, &block)
+        end
+      end
+      alias_method :append_before, :before
+
+      # Adds `block` to the start of the list of `before` blocks in the same
+      # scope (`:example`, `:context`, or `:suite`), in contrast to {#before},
+      # which adds the hook to the end of the list.
+      #
+      # See {Hooks#before} for full `before` hook docs.
+      #
+      # This method differs from {Hooks#prepend_before} in only one way: it supports
+      # the `:suite` scope. Hooks with the `:suite` scope will be run once before
+      # the first example of the entire suite is executed. Conditions passed along
+      # with `:suite` are effectively ignored.
+      #
+      # @see #before
+      # @see #after
+      # @see #append_after
+      def prepend_before(scope=nil, *meta, &block)
+        handle_suite_hook(scope, meta) do
+          @before_suite_hooks.unshift Hooks::BeforeHook.new(block, {})
+        end || begin
+          # defeat Ruby 2.5 lazy proc allocation to ensure
+          # the methods below are passed the same proc instances
+          # so `Hook` equality is preserved. For more info, see:
+          # https://bugs.ruby-lang.org/issues/14045#note-5
+          block.__id__
+
+          add_hook_to_existing_matching_groups(meta, scope) { |g| g.prepend_before(scope, *meta, &block) }
+          super(scope, *meta, &block)
+        end
+      end
+
+      # Defines a `after` hook. See {Hooks#after} for full docs.
+      #
+      # This method differs from {Hooks#after} in only one way: it supports
+      # the `:suite` scope. Hooks with the `:suite` scope will be run once after
+      # the last example of the entire suite is executed. Conditions passed along
+      # with `:suite` are effectively ignored.
+      #
+      # @see #append_after
+      # @see #before
+      # @see #prepend_before
+      def after(scope=nil, *meta, &block)
+        handle_suite_hook(scope, meta) do
+          @after_suite_hooks.unshift Hooks::AfterHook.new(block, {})
+        end || begin
+          # defeat Ruby 2.5 lazy proc allocation to ensure
+          # the methods below are passed the same proc instances
+          # so `Hook` equality is preserved. For more info, see:
+          # https://bugs.ruby-lang.org/issues/14045#note-5
+          block.__id__
+
+          add_hook_to_existing_matching_groups(meta, scope) { |g| g.after(scope, *meta, &block) }
+          super(scope, *meta, &block)
+        end
+      end
+      alias_method :prepend_after, :after
+
+      # Adds `block` to the end of the list of `after` blocks in the same
+      # scope (`:example`, `:context`, or `:suite`), in contrast to {#after},
+      # which adds the hook to the start of the list.
+      #
+      # See {Hooks#after} for full `after` hook docs.
+      #
+      # This method differs from {Hooks#append_after} in only one way: it supports
+      # the `:suite` scope. Hooks with the `:suite` scope will be run once after
+      # the last example of the entire suite is executed. Conditions passed along
+      # with `:suite` are effectively ignored.
+      #
+      # @see #append_after
+      # @see #before
+      # @see #prepend_before
+      def append_after(scope=nil, *meta, &block)
+        handle_suite_hook(scope, meta) do
+          @after_suite_hooks << Hooks::AfterHook.new(block, {})
+        end || begin
+          # defeat Ruby 2.5 lazy proc allocation to ensure
+          # the methods below are passed the same proc instances
+          # so `Hook` equality is preserved. For more info, see:
+          # https://bugs.ruby-lang.org/issues/14045#note-5
+          block.__id__
+
+          add_hook_to_existing_matching_groups(meta, scope) { |g| g.append_after(scope, *meta, &block) }
+          super(scope, *meta, &block)
+        end
+      end
+
+      # Registers `block` as an `around` hook.
+      #
+      # See {Hooks#around} for full `around` hook docs.
+      def around(scope=nil, *meta, &block)
+        # defeat Ruby 2.5 lazy proc allocation to ensure
+        # the methods below are passed the same proc instances
+        # so `Hook` equality is preserved. For more info, see:
+        # https://bugs.ruby-lang.org/issues/14045#note-5
+        block.__id__
+
+        add_hook_to_existing_matching_groups(meta, scope) { |g| g.around(scope, *meta, &block) }
+        super(scope, *meta, &block)
+      end
+
+      # @private
+      def with_suite_hooks
+        return yield if dry_run?
+
+        begin
+          RSpec.current_scope = :before_suite_hook
+          run_suite_hooks("a `before(:suite)` hook", @before_suite_hooks)
+          yield
+        ensure
+          RSpec.current_scope = :after_suite_hook
+          run_suite_hooks("an `after(:suite)` hook", @after_suite_hooks)
+          RSpec.current_scope = :suite
+        end
+      end
+
+      # @private
+      # Holds the various registered hooks. Here we use a FilterableItemRepository
+      # implementation that is specifically optimized for the read/write patterns
+      # of the config object.
+      def hooks
+        @hooks ||= HookCollections.new(self, FilterableItemRepository::QueryOptimized)
+      end
+
+      # Invokes block before defining an example group
+      def on_example_group_definition(&block)
+        on_example_group_definition_callbacks << block
+      end
+
+      # @api private
+      # Returns an array of blocks to call before defining an example group
+      def on_example_group_definition_callbacks
+        @on_example_group_definition_callbacks ||= []
+      end
+
+      # @private
+      def bisect_runner_class
+        @bisect_runner_class ||= begin
+          case bisect_runner
+          when :fork
+            RSpec::Support.require_rspec_core 'bisect/fork_runner'
+            Bisect::ForkRunner
+          when :shell
+            RSpec::Support.require_rspec_core 'bisect/shell_runner'
+            Bisect::ShellRunner
+          else
+            raise "Unsupported value for `bisect_runner` (#{bisect_runner.inspect}). " \
+                  "Only `:fork` and `:shell` are supported."
+          end
         end
       end
 
     private
 
+      def load_file_handling_errors(method, file)
+        __send__(method, file)
+      rescue LoadError => ex
+        relative_file = Metadata.relative_path(file)
+        suggestions = DidYouMean.new(relative_file).call
+        reporter.notify_non_example_exception(ex, "An error occurred while loading #{relative_file}.#{suggestions}")
+        RSpec.world.wants_to_quit = true
+      rescue Support::AllExceptionsExceptOnesWeMustNotRescue => ex
+        relative_file = Metadata.relative_path(file)
+        reporter.notify_non_example_exception(ex, "An error occurred while loading #{relative_file}.")
+        RSpec.world.wants_to_quit = true
+      rescue SystemExit => ex
+        relative_file = Metadata.relative_path(file)
+        reporter.notify_non_example_exception(
+          ex,
+          "While loading #{relative_file} an `exit` / `raise SystemExit` occurred, RSpec will now quit."
+        )
+        RSpec.world.rspec_is_quitting = true
+        raise ex
+      end
+
+      def handle_suite_hook(scope, meta)
+        return nil unless scope == :suite
+
+        unless meta.empty?
+          # TODO: in RSpec 4, consider raising an error here.
+          # We warn only for backwards compatibility.
+          RSpec.warn_with "WARNING: `:suite` hooks do not support metadata since " \
+                          "they apply to the suite as a whole rather than " \
+                          "any individual example or example group that has metadata. " \
+                          "The metadata you have provided (#{meta.inspect}) will be ignored."
+        end
+
+        yield
+      end
+
+      def run_suite_hooks(hook_description, hooks)
+        context = SuiteHookContext.new(hook_description, reporter)
+
+        hooks.each do |hook|
+          begin
+            hook.run(context)
+          rescue Support::AllExceptionsExceptOnesWeMustNotRescue => ex
+            context.set_exception(ex)
+
+            # Do not run subsequent `before` hooks if one fails.
+            # But for `after` hooks, we run them all so that all
+            # cleanup bits get a chance to complete, minimizing the
+            # chance that resources get left behind.
+            break if hooks.equal?(@before_suite_hooks)
+          end
+        end
+      end
+
       def get_files_to_run(paths)
-        FlatMap.flat_map(paths_to_check(paths)) do |path|
+        files = FlatMap.flat_map(paths_to_check(paths)) do |path|
           path = path.gsub(File::ALT_SEPARATOR, File::SEPARATOR) if File::ALT_SEPARATOR
           File.directory?(path) ? gather_directories(path) : extract_location(path)
-        end.sort.uniq
+        end.uniq
+
+        return files unless only_failures?
+        relative_files = files.map { |f| Metadata.relative_path(File.expand_path f) }
+        intersection = (relative_files & spec_files_with_failures.to_a)
+        intersection.empty? ? files : intersection
       end
 
       def paths_to_check(paths)
         return paths if pattern_might_load_specs_from_vendored_dirs?
-        paths + ['.']
+        paths + [Dir.getwd]
       end
 
       def pattern_might_load_specs_from_vendored_dirs?
@@ -1341,11 +2191,12 @@ module RSpec
       def gather_directories(path)
         include_files = get_matching_files(path, pattern)
         exclude_files = get_matching_files(path, exclude_pattern)
-        (include_files - exclude_files).sort.uniq
+        (include_files - exclude_files).uniq
       end
 
       def get_matching_files(path, pattern)
-        Dir[file_glob_from(path, pattern)].map { |file| File.expand_path(file) }
+        raw_files = Dir[file_glob_from(path, pattern)]
+        raw_files.map { |file| File.expand_path(file) }.sort
       end
 
       def file_glob_from(path, pattern)
@@ -1355,6 +2206,7 @@ module RSpec
       end
 
       if RSpec::Support::OS.windows?
+        # :nocov:
         def absolute_pattern?(pattern)
           pattern =~ /\A[A-Z]:\\/ || windows_absolute_network_path?(pattern)
         end
@@ -1363,6 +2215,7 @@ module RSpec
           return false unless ::File::ALT_SEPARATOR
           pattern.start_with?(::File::ALT_SEPARATOR + ::File::ALT_SEPARATOR)
         end
+        # :nocov:
       else
         def absolute_pattern?(pattern)
           pattern.start_with?(File::Separator)
@@ -1374,24 +2227,38 @@ module RSpec
 
         if match
           captures = match.captures
-          path, lines = captures[0], captures[1][1..-1].split(":").map { |n| n.to_i }
+          path = captures[0]
+          lines = captures[1][1..-1].split(":").map(&:to_i)
           filter_manager.add_location path, lines
+        else
+          path, scoped_ids = Example.parse_id(path)
+          filter_manager.add_ids(path, scoped_ids.split(/\s*,\s*/)) if scoped_ids
         end
 
         return [] if path == default_path
-        path
+        File.expand_path(path)
       end
 
       def command
         $0.split(File::SEPARATOR).last
       end
 
-      def value_for(key, default=nil)
-        @preferred_options.key?(key) ? @preferred_options[key] : default
+      def value_for(key)
+        @preferred_options.fetch(key) { yield }
+      end
+
+      def define_built_in_hooks
+        around(:example, :aggregate_failures => true) do |procsy|
+          begin
+            aggregate_failures(nil, :hide_backtrace => true, &procsy)
+          rescue Support::AllExceptionsExceptOnesWeMustNotRescue => exception
+            procsy.example.set_aggregate_failures_exception(exception)
+          end
+        end
       end
 
       def assert_no_example_groups_defined(config_option)
-        return unless RSpec.world.example_groups.any?
+        return unless world.example_groups.any?
 
         raise MustBeConfiguredBeforeExampleGroupsError.new(
           "RSpec's #{config_option} configuration option must be configured before " \
@@ -1399,8 +2266,12 @@ module RSpec
         )
       end
 
+      def output_wrapper
+        @output_wrapper ||= OutputWrapper.new(output_stream)
+      end
+
       def output_to_tty?(output=output_stream)
-        tty? || (output.respond_to?(:tty?) && output.tty?)
+        output.respond_to?(:tty?) && output.tty?
       end
 
       def conditionally_disable_mocks_monkey_patching
@@ -1428,13 +2299,87 @@ module RSpec
 
       def update_pattern_attr(name, value)
         if @spec_files_loaded
-          RSpec.warning "Configuring `#{name}` to #{value} has no effect since RSpec has already loaded the spec files."
+          RSpec.warning "Configuring `#{name}` to #{value} has no effect since " \
+                        "RSpec has already loaded the spec files."
         end
 
         instance_variable_set(:"@#{name}", value)
         @files_to_run = nil
       end
+
+      def clear_values_derived_from_example_status_persistence_file_path
+        @last_run_statuses = nil
+        @spec_files_with_failures = nil
+      end
+
+      def configure_group_with(group, module_list, application_method)
+        module_list.items_for(group.metadata).each do |mod|
+          __send__(application_method, mod, group)
+        end
+      end
+
+      def add_hook_to_existing_matching_groups(meta, scope, &block)
+        # For example hooks, we have to apply it to each of the top level
+        # groups, even if the groups do not match. When we apply it, we
+        # apply it with the metadata, so it will only apply to examples
+        # in the group that match the metadata.
+        # #2280 for background and discussion.
+        if scope == :example || scope == :each || scope.nil?
+          world.example_groups.each(&block)
+        else
+          meta = Metadata.build_hash_from(meta.dup)
+          on_existing_matching_groups(meta, &block)
+        end
+      end
+
+      def on_existing_matching_groups(meta)
+        world.traverse_example_group_trees_until do |group|
+          metadata_applies_to_group?(meta, group).tap do |applies|
+            yield group if applies
+          end
+        end
+      end
+
+      def metadata_applies_to_group?(meta, group)
+        meta.empty? || MetadataFilter.apply?(:any?, meta, group.metadata)
+      end
+
+      if RSpec::Support::RubyFeatures.module_prepends_supported?
+        def safe_prepend(mod, host)
+          host.__send__(:prepend, mod) unless host < mod
+        end
+      end
+
+      if RUBY_VERSION.to_f >= 1.9
+        def safe_include(mod, host)
+          host.__send__(:include, mod) unless host < mod
+        end
+
+        def safe_extend(mod, host)
+          host.extend(mod) unless host.singleton_class < mod
+        end
+      else # for 1.8.7
+        # :nocov:
+        def safe_include(mod, host)
+          host.__send__(:include, mod) unless host.included_modules.include?(mod)
+        end
+
+        def safe_extend(mod, host)
+          host.extend(mod) unless (class << host; self; end).included_modules.include?(mod)
+        end
+        # :nocov:
+      end
+
+      def define_mixed_in_module(mod, filters, mod_list, config_method, &block)
+        unless Module === mod
+          raise TypeError, "`RSpec.configuration.#{config_method}` expects a module but got: #{mod.inspect}"
+        end
+
+        meta = Metadata.build_hash_from(filters, :warn_about_example_group_filtering)
+        mod_list.append(mod, meta)
+        on_existing_matching_groups(meta, &block)
+      end
     end
-    # rubocop:enable Style/ClassLength
+    # rubocop:enable Metrics/ClassLength
   end
 end