opal-rspec 0.8.0.alpha3 → 1.0.0.alpha1

data/rspec-core/upstream/features/clear_examples.feature

@@ -0,0 +1,106 @@
+Feature: Running specs multiple times with different runner options in the same process
+
+  Use `clear_examples` command to clear all example groups between different
+  runs in the same process. It:
+
+  - clears all example groups
+  - restores inclusion and exclusion filters set by configuration
+  - clears inclusion and exclusion filters set by previous spec run (via runner)
+  - resets all time counters (start time, load time, duration, etc.)
+  - resets different counts of examples (all examples, pending and failed)
+
+  ```ruby
+  require "spec_helper"
+
+  RSpec::Core::Runner.run([... some parameters ...])
+
+  RSpec.clear_examples
+
+  RSpec::Core::Runner.run([... different parameters ...])
+  ```
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.filter_run_when_matching :focus => true
+        config.filter_run_excluding :slow => true
+      end
+      """
+    Given a file named "spec/truth_spec.rb" with:
+    """ruby
+    require 'spec_helper'
+
+    RSpec.describe "truth" do
+      describe true do
+        it "is truthy" do
+          expect(true).to be_truthy
+        end
+
+        it "is not falsy" do
+          expect(true).not_to be_falsy
+        end
+      end
+
+      describe false do
+        it "is falsy" do
+          expect(false).to be_falsy
+        end
+
+        it "is truthy" do
+          expect(false).not_to be_truthy
+        end
+      end
+    end
+    """
+
+  Scenario: Running specs multiple times in the same process
+    Given a file named "scripts/multiple_runs.rb" with:
+      """ruby
+      require 'rspec/core'
+
+      RSpec::Core::Runner.run(['spec'])
+      RSpec.clear_examples
+      RSpec::Core::Runner.run(['spec'])
+      """
+    When I run `ruby scripts/multiple_runs.rb`
+    Then the output should match:
+      """
+      4 examples, 0 failures
+      .*
+      4 examples, 0 failures
+      """
+
+  Scenario: Running specs multiple times in the same process with different parameters
+    Given a file named "spec/bar_spec.rb" with:
+      """ruby
+      require 'spec_helper'
+
+      RSpec.describe 'bar' do
+        subject(:bar) { :focused }
+
+        it 'is focused', :focus do
+          expect(bar).to be(:focused)
+        end
+      end
+      """
+    Given a file named "scripts/different_parameters.rb" with:
+      """ruby
+      require 'rspec/core'
+
+      RSpec::Core::Runner.run(['spec'])
+      RSpec.clear_examples
+      RSpec::Core::Runner.run(['spec/truth_spec.rb:4'])
+      RSpec.clear_examples
+      RSpec::Core::Runner.run(['spec', '-e', 'fals'])
+      """
+    When I run `ruby scripts/different_parameters.rb`
+    Then the output should match:
+      """
+      1 example, 0 failures
+      .*
+      2 examples, 0 failures
+      .*
+      3 examples, 0 failures
+      """
+

data/rspec-core/upstream/features/command_line/bisect.feature

@@ -0,0 +1,178 @@
+@with-clean-spec-opts
+Feature: Bisect
+
+  RSpec's `--order random` and `--seed` options help surface flickering examples that only fail when one or more other examples are executed first. It can be very difficult to isolate the exact combination of examples that triggers the failure. The `--bisect` flag helps solve that problem.
+
+  Pass the `--bisect` option (in addition to `--seed` and any other options) and RSpec will repeatedly run subsets of your suite in order to isolate the minimal set of examples that reproduce the same failures.
+
+  At any point during the bisect run, you can hit ctrl-c to abort and it will provide you with the most minimal reproduction command it has discovered so far.
+
+  To get more detailed output (particularly useful if you want to report a bug with bisect), use `--bisect=verbose`.
+
+  Background:
+    Given a file named "lib/calculator.rb" with:
+      """ruby
+      class Calculator
+        def self.add(x, y)
+          x + y
+        end
+      end
+      """
+    And a file named "spec/calculator_1_spec.rb" with:
+      """ruby
+      require 'calculator'
+
+      RSpec.describe "Calculator" do
+        it 'adds numbers' do
+          expect(Calculator.add(1, 2)).to eq(3)
+        end
+      end
+      """
+    And files "spec/calculator_2_spec.rb" through "spec/calculator_9_spec.rb" with an unrelated passing spec in each file
+    And a file named "spec/calculator_10_spec.rb" with:
+      """ruby
+      require 'calculator'
+
+      RSpec.describe "Monkey patched Calculator" do
+        it 'does screwy math' do
+          # monkey patching `Calculator` affects examples that are
+          # executed after this one!
+          def Calculator.add(x, y)
+            x - y
+          end
+
+          expect(Calculator.add(5, 10)).to eq(-5)
+        end
+      end
+      """
+
+  Scenario: Use `--bisect` flag to create a minimal repro case for the ordering dependency
+    When I run `rspec --seed 1234`
+    Then the output should contain "10 examples, 1 failure"
+    When I run `rspec --seed 1234 --bisect`
+    Then bisect should succeed with output like:
+      """
+      Bisect started using options: "--seed 1234"
+      Running suite to find failures... (0.16755 seconds)
+      Starting bisect with 1 failing example and 9 non-failing examples.
+      Checking that failure(s) are order-dependent... failure appears to be order-dependent
+
+      Round 1: bisecting over non-failing examples 1-9 .. ignoring examples 6-9 (0.30166 seconds)
+      Round 2: bisecting over non-failing examples 1-5 .. ignoring examples 4-5 (0.30306 seconds)
+      Round 3: bisecting over non-failing examples 1-3 .. ignoring example 3 (0.33292 seconds)
+      Round 4: bisecting over non-failing examples 1-2 . ignoring example 1 (0.16476 seconds)
+      Bisect complete! Reduced necessary non-failing examples from 9 to 1 in 1.26 seconds.
+
+      The minimal reproduction command is:
+        rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] --seed 1234
+      """
+    When I run `rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] --seed 1234`
+    Then the output should contain "2 examples, 1 failure"
+
+  Scenario: Ctrl-C can be used to abort the bisect early and get the most minimal command it has discovered so far
+    When I run `rspec --seed 1234 --bisect` and abort in the middle with ctrl-c
+    Then bisect should fail with output like:
+      """
+      Bisect started using options: "--seed 1234"
+      Running suite to find failures... (0.17102 seconds)
+      Starting bisect with 1 failing example and 9 non-failing examples.
+      Checking that failure(s) are order-dependent... failure appears to be order-dependent
+
+      Round 1: bisecting over non-failing examples 1-9 .. ignoring examples 6-9 (0.32943 seconds)
+      Round 2: bisecting over non-failing examples 1-5 .. ignoring examples 4-5 (0.3154 seconds)
+      Round 3: bisecting over non-failing examples 1-3 .. ignoring example 3 (0.2175 seconds)
+
+      Bisect aborted!
+
+      The most minimal reproduction command discovered so far is:
+        rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] ./spec/calculator_3_spec.rb[1:1] --seed 1234
+      """
+    When I run `rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] ./spec/calculator_3_spec.rb[1:1] --seed 1234`
+    Then the output should contain "3 examples, 1 failure"
+
+  Scenario: Use `--bisect=verbose` to enable verbose debug mode for more detail
+    When I run `rspec --seed 1234 --bisect=verbose`
+    Then bisect should succeed with output like:
+      """
+      Bisect started using options: "--seed 1234" and bisect runner: :fork
+      Running suite to find failures... (0.16528 seconds)
+       - Failing examples (1):
+          - ./spec/calculator_1_spec.rb[1:1]
+       - Non-failing examples (9):
+          - ./spec/calculator_10_spec.rb[1:1]
+          - ./spec/calculator_2_spec.rb[1:1]
+          - ./spec/calculator_3_spec.rb[1:1]
+          - ./spec/calculator_4_spec.rb[1:1]
+          - ./spec/calculator_5_spec.rb[1:1]
+          - ./spec/calculator_6_spec.rb[1:1]
+          - ./spec/calculator_7_spec.rb[1:1]
+          - ./spec/calculator_8_spec.rb[1:1]
+          - ./spec/calculator_9_spec.rb[1:1]
+      Checking that failure(s) are order-dependent..
+       - Running: rspec ./spec/calculator_1_spec.rb[1:1] --seed 1234 (n.nnnn seconds)
+       - Failure appears to be order-dependent
+      Round 1: bisecting over non-failing examples 1-9
+       - Running: rspec ./spec/calculator_1_spec.rb[1:1] ./spec/calculator_6_spec.rb[1:1] ./spec/calculator_7_spec.rb[1:1] ./spec/calculator_8_spec.rb[1:1] ./spec/calculator_9_spec.rb[1:1] --seed 1234 (0.15302 seconds)
+       - Running: rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] ./spec/calculator_2_spec.rb[1:1] ./spec/calculator_3_spec.rb[1:1] ./spec/calculator_4_spec.rb[1:1] ./spec/calculator_5_spec.rb[1:1] --seed 1234 (0.19708 seconds)
+       - Examples we can safely ignore (4):
+          - ./spec/calculator_6_spec.rb[1:1]
+          - ./spec/calculator_7_spec.rb[1:1]
+          - ./spec/calculator_8_spec.rb[1:1]
+          - ./spec/calculator_9_spec.rb[1:1]
+       - Remaining non-failing examples (5):
+          - ./spec/calculator_10_spec.rb[1:1]
+          - ./spec/calculator_2_spec.rb[1:1]
+          - ./spec/calculator_3_spec.rb[1:1]
+          - ./spec/calculator_4_spec.rb[1:1]
+          - ./spec/calculator_5_spec.rb[1:1]
+      Round 2: bisecting over non-failing examples 1-5
+       - Running: rspec ./spec/calculator_1_spec.rb[1:1] ./spec/calculator_4_spec.rb[1:1] ./spec/calculator_5_spec.rb[1:1] --seed 1234 (0.15836 seconds)
+       - Running: rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] ./spec/calculator_2_spec.rb[1:1] ./spec/calculator_3_spec.rb[1:1] --seed 1234 (0.19065 seconds)
+       - Examples we can safely ignore (2):
+          - ./spec/calculator_4_spec.rb[1:1]
+          - ./spec/calculator_5_spec.rb[1:1]
+       - Remaining non-failing examples (3):
+          - ./spec/calculator_10_spec.rb[1:1]
+          - ./spec/calculator_2_spec.rb[1:1]
+          - ./spec/calculator_3_spec.rb[1:1]
+      Round 3: bisecting over non-failing examples 1-3
+       - Running: rspec ./spec/calculator_1_spec.rb[1:1] ./spec/calculator_2_spec.rb[1:1] --seed 1234 (0.21028 seconds)
+       - Running: rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] ./spec/calculator_3_spec.rb[1:1] --seed 1234 (0.1975 seconds)
+       - Examples we can safely ignore (1):
+          - ./spec/calculator_2_spec.rb[1:1]
+       - Remaining non-failing examples (2):
+          - ./spec/calculator_10_spec.rb[1:1]
+          - ./spec/calculator_3_spec.rb[1:1]
+      Round 4: bisecting over non-failing examples 1-2
+       - Running: rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] --seed 1234 (0.17173 seconds)
+       - Examples we can safely ignore (1):
+          - ./spec/calculator_3_spec.rb[1:1]
+       - Remaining non-failing examples (1):
+          - ./spec/calculator_10_spec.rb[1:1]
+      Bisect complete! Reduced necessary non-failing examples from 9 to 1 in 1.47 seconds.
+
+      The minimal reproduction command is:
+        rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] --seed 1234
+      """
+    When I run `rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] --seed 1234`
+    Then the output should contain "2 examples, 1 failure"
+
+  Scenario: Pick a bisect runner via a config option
+    Given a file named "spec/spec_helper.rb" with:
+      """
+      RSpec.configure do |c|
+        c.bisect_runner = :shell
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      """
+    When I run `rspec --seed 1234 --bisect=verbose`
+    Then bisect should succeed with output like:
+      """
+      Bisect started using options: "--seed 1234" and bisect runner: :shell
+      # ...
+      The minimal reproduction command is:
+        rspec ./spec/calculator_10_spec.rb[1:1] ./spec/calculator_1_spec.rb[1:1] --seed 1234
+      """

data/rspec-core/upstream/features/command_line/example_matches_name_option.feature

@@ -0,0 +1,131 @@
+Feature: `--example-matches` option
+
+  Use the `--example-matches` (or `-E`) option to filter examples by name using REGEX.
+
+  The argument is matched against the full description of the example, which is
+  the concatenation of descriptions of the group (including any nested groups)
+  and the example.
+
+  This allows you to run a single uniquely named example, all examples with
+  similar names, all the examples in a uniquely named group, etc, etc.
+
+  You can also use the option more than once to specify multiple example
+  matches.
+
+  Note: description-less examples that have generated descriptions (typical when using the [one-liner syntax](../subject/one-liner-syntax)) cannot be directly filtered with this option, because it is necessary to execute the example to generate the description, so RSpec is unable to use the not-yet-generated description to decide whether or not to execute an example. You can, of course, pass part of a group's description to select all examples defined in the group (including those that have no description).
+
+  Background:
+    Given a file named "first_spec.rb" with:
+      """ruby
+      RSpec.describe "first group" do
+        it "first" do; end
+        it "first example in first group" do; end
+        it "second example in first group" do; end
+      end
+      """
+    And a file named "second_spec.rb" with:
+      """ruby
+      RSpec.describe "second group" do
+        it "first example in second group" do; end
+        it "second example in second group" do; end
+      end
+      """
+    And a file named "third_spec.rb" with:
+      """ruby
+      RSpec.describe "third group" do
+        it "first example in third group" do; end
+        context "group of nest" do
+          it "first example in nested group" do; end
+          it "second example in nested group" do; end
+          it "third example in nested_group with underscore" do; end
+        end
+      end
+      """
+    And a file named "fourth_spec.rb" with:
+      """ruby
+      RSpec.describe Array do
+        describe "#length" do
+          it "is the number of items" do
+            expect(Array.new([1,2,3]).length).to eq 3
+          end
+        end
+      end
+      """
+
+  Scenario: No matches
+    When I run `rspec . --example-matches nothing_like_this`
+    Then the process should succeed even though no examples were run
+
+  Scenario: Match on one word
+    When I run `rspec . --example-matches example`
+    Then the examples should all pass
+
+  Scenario: One match in each context
+    When I run `rspec . --example-matches 'first example'`
+    Then the examples should all pass
+
+  Scenario: One match in one file using just the example name
+    When I run `rspec . --example-matches 'first example in first group'`
+    Then the examples should all pass
+
+  Scenario: One match in one file using the example name and the group name
+    When I run `rspec . --example-matches 'first group first example in first group'`
+    Then the examples should all pass
+
+  Scenario: All examples in one group
+    When I run `rspec . --example-matches 'first group'`
+    Then the examples should all pass
+
+  Scenario: One match in one file with group name
+    When I run `rspec . --example-matches 'second group first example'`
+    Then the examples should all pass
+
+  Scenario: All examples in one group including examples in nested groups
+    When I run `rspec . --example-matches 'third group'`
+    Then the examples should all pass
+
+  Scenario: Match using `ClassName#method_name` form
+    When I run `rspec . --example-matches 'Array#length'`
+    Then the examples should all pass
+
+  Scenario: Match only matching regex
+    When I run `rspec . --example-matches "first$" --format d`
+    Then the examples should all pass
+    And the output should contain all of these:
+      | first |
+    And the output should not contain any of these:
+      | first example in first group                |
+      | second example in first group               |
+      | first example in second group               |
+      | second example in second group              |
+      | first example in third group                |
+      | nested group first example in nested group  |
+      | nested group second example in nested group |
+
+  # https://regex101.com/r/RABd8Q/2
+  Scenario: Match only matching regex with word boundarries
+    When I run `rspec . --example-matches "nested[^_]" --format d`
+    Then the examples should all pass
+    And the output should contain all of these:
+      | first example in nested group  |
+      | second example in nested group |
+    And the output should not contain any of these:
+      | first example in first group   |
+      | second example in first group  |
+      | first example in second group  |
+      | second example in second group |
+      | first example in third group   |
+      | third example in nested_group  |
+
+  Scenario: Multiple applications of example name option
+    When I run `rspec . --example-matches 'first group' --example-matches 'second group' --format d`
+    Then the examples should all pass
+    And the output should contain all of these:
+      | first example in first group   |
+      | second example in first group  |
+      | first example in second group  |
+      | second example in second group |
+    And the output should not contain any of these:
+      | first example in third group                |
+      | nested group first example in nested group  |
+      | nested group second example in nested group |

data/rspec-core/upstream/features/command_line/example_name_option.feature

@@ -12,6 +12,8 @@ Feature: `--example` option
   You can also use the option more than once to specify multiple example
   matches.
 
+  Note: description-less examples that have generated descriptions (typical when using the [one-liner syntax](../subject/one-liner-syntax)) cannot be directly filtered with this option, because it is necessary to execute the example to generate the description, so RSpec is unable to use the not-yet-generated description to decide whether or not to execute an example. You can, of course, pass part of a group's description to select all examples defined in the group (including those that have no description).
+
   Background:
     Given a file named "first_spec.rb" with:
       """ruby

data/rspec-core/upstream/features/command_line/fail_fast.feature

@@ -3,17 +3,29 @@ Feature: `--fail-fast` option
   Use the `--fail-fast` option to tell RSpec to stop running the test suite on
   the first failed test.
 
-  You may also specify `--no-fail-fast` to turn it off (default behaviour).
+  You may add a parameter to tell RSpec to stop running the test suite after N
+  failed tests, for example: `--fail-fast=3`.
+
+  You can also specify `--no-fail-fast` to turn it off (default behaviour).
 
   Background:
     Given a file named "fail_fast_spec.rb" with:
       """ruby
       RSpec.describe "fail fast" do
         it "passing test" do; end
-        it "failing test" do
+        it "1st failing test" do
+          fail
+        end
+        it "2nd failing test" do
+          fail
+        end
+        it "3rd failing test" do
           fail
         end
-        it "this should not be run" do; end
+        it "4th failing test" do
+          fail
+        end
+        it "passing test" do; end
       end
       """
 
@@ -22,6 +34,11 @@ Feature: `--fail-fast` option
     Then the output should contain ".F"
     Then the output should not contain ".F."
 
+  Scenario: Using `--fail-fast=3`
+    When I run `rspec . --fail-fast=3`
+    Then the output should contain ".FFF"
+    Then the output should not contain ".FFFF."
+
   Scenario: Using `--no-fail-fast`
     When I run `rspec . --no-fail-fast`
-    Then the output should contain ".F."
+    Then the output should contain ".FFFF."

data/rspec-core/upstream/features/command_line/init.feature

@@ -17,7 +17,7 @@ Feature: `--init` option
   Scenario: `.rspec` file already exists
     Given a file named ".rspec" with:
       """
-      --color
+      --force-color
       """
     When I run `rspec --init`
     Then the output should contain "exist   .rspec"
@@ -25,7 +25,7 @@ Feature: `--init` option
   Scenario: Accept and use the recommended settings in `spec_helper` (which are initially commented out)
     Given I have a brand new project with no files
       And I have run `rspec --init`
-     When I accept the recommended settings by removing `=begin` and `=end` from `spec/spec_helper.rb`
+     When I accept the recommended settings by removing `=begin` and `=end` from `spec_helper.rb`
       And I create "spec/addition_spec.rb" with the following content:
         """ruby
         RSpec.describe "Addition" do

data/rspec-core/upstream/features/command_line/line_number_appended_to_path.feature

@@ -155,5 +155,5 @@ Feature: line number appended to file path
   Scenario: Matching one-liners
     When I run `rspec one_liner_spec.rb:3 --format doc`
     Then the examples should all pass
-    Then the output should contain "should be > 8"
-    But the output should not contain "should be < 10"
+    Then the output should contain "is expected to be > 8"
+    But the output should not contain "is expected to be < 10"

data/rspec-core/upstream/features/command_line/only_failures.feature

@@ -0,0 +1,113 @@
+Feature: Only Failures
+
+  The `--only-failures` option filters what examples are run so that only those that failed the last time they ran are executed. To use this option, you first have to configure `config.example_status_persistence_file_path`, which RSpec will use to store the status of each example the last time it ran.
+
+  There's also a `--next-failure` option, which is shorthand for `--only-failures --fail-fast --order defined`. It allows you to repeatedly focus on just one of the currently failing examples, then move on to the next failure, etc.
+
+  Either of these options can be combined with another a directory or file name; RSpec will run just the failures from the set of loaded examples.
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure do |c|
+        c.example_status_persistence_file_path = "examples.txt"
+      end
+      """
+    And a file named ".rspec" with:
+      """
+      --require spec_helper
+      --order random
+      --format documentation
+      """
+    And a file named "spec/array_spec.rb" with:
+      """ruby
+      RSpec.describe 'Array' do
+        it "checks for inclusion of 1" do
+          expect([1, 2]).to include(1)
+        end
+
+        it "checks for inclusion of 2" do
+          expect([1, 2]).to include(2)
+        end
+
+        it "checks for inclusion of 3" do
+          expect([1, 2]).to include(3) # failure
+        end
+      end
+      """
+    And a file named "spec/string_spec.rb" with:
+      """ruby
+      RSpec.describe 'String' do
+        it "checks for inclusion of 'foo'" do
+          expect("food").to include('foo')
+        end
+
+        it "checks for inclusion of 'bar'" do
+          expect("food").to include('bar') # failure
+        end
+
+        it "checks for inclusion of 'baz'" do
+          expect("bazzy").to include('baz')
+        end
+
+        it "checks for inclusion of 'foobar'" do
+          expect("food").to include('foobar') # failure
+        end
+      end
+      """
+    And a file named "spec/passing_spec.rb" with:
+      """ruby
+      puts "Loading passing_spec.rb"
+
+      RSpec.describe "A passing spec" do
+        it "passes" do
+          expect(1).to eq(1)
+        end
+      end
+      """
+    And I have run `rspec` once, resulting in "8 examples, 3 failures"
+
+  Scenario: Running `rspec --only-failures` loads only spec files with failures and runs only the failures
+    When I run `rspec --only-failures`
+    Then the output from "rspec --only-failures" should contain "3 examples, 3 failures"
+     And the output from "rspec --only-failures" should not contain "Loading passing_spec.rb"
+
+  Scenario: Combine `--only-failures` with a file name
+    When I run `rspec spec/array_spec.rb --only-failures`
+    Then the output should contain "1 example, 1 failure"
+    When I run `rspec spec/string_spec.rb --only-failures`
+    Then the output should contain "2 examples, 2 failures"
+
+  Scenario: Use `--next-failure` to repeatedly run a single failure
+    When I run `rspec --next-failure`
+    Then the output should contain "1 example, 1 failure"
+     And the output should contain "checks for inclusion of 3"
+
+    When I fix "spec/array_spec.rb" by replacing "to include(3)" with "not_to include(3)"
+     And I run `rspec --next-failure`
+    Then the output should contain "2 examples, 1 failure"
+     And the output should contain "checks for inclusion of 3"
+     And the output should contain "checks for inclusion of 'bar'"
+
+    When I fix "spec/string_spec.rb" by replacing "to include('bar')" with "not_to include('bar')"
+     And I run `rspec --next-failure`
+    Then the output should contain "2 examples, 1 failure"
+     And the output should contain "checks for inclusion of 'bar'"
+     And the output should contain "checks for inclusion of 'foobar'"
+
+    When I fix "spec/string_spec.rb" by replacing "to include('foobar')" with "not_to include('foobar')"
+     And I run `rspec --next-failure`
+    Then the output should contain "1 example, 0 failures"
+     And the output should contain "checks for inclusion of 'foobar'"
+
+    When I run `rspec --next-failure`
+    Then the output should contain "All examples were filtered out"
+
+  Scenario: Running `rspec --only-failures` with spec files that pass doesn't run anything
+    When I run `rspec spec/passing_spec.rb --only-failures`
+    Then it should pass with "0 examples, 0 failures"
+
+  Scenario: Clear error given when using `--only-failures` without configuring `example_status_persistence_file_path`
+    Given I have not configured `example_status_persistence_file_path`
+     When I run `rspec --only-failures`
+     Then it should fail with "To use `--only-failures`, you must first set `config.example_status_persistence_file_path`."

data/rspec-core/upstream/features/command_line/order.md

@@ -2,7 +2,9 @@ Use the `--order` option to tell RSpec how to order the files, groups, and
 examples. The available ordering schemes are `defined` and `rand`.
 
 `defined` is the default, which executes groups and examples in the order they
-are defined as the spec files are loaded.
+are defined as the spec files are loaded, with the caveat that each group
+runs its examples before running its nested example groups, even if the
+nested groups are defined before the examples.
 
 Use `rand` to randomize the order of groups and examples within the groups.
 Nested groups are always run from top-level to bottom-level in order to avoid
@@ -11,6 +13,10 @@ order of groups at each level is randomized.
 
 With `rand` you can also specify a seed.
 
+Use `recently-modified` to run the most recently modified files first. You can
+combine it with `--only-failures` to find the most recent failing specs. Note
+that `recently-modified` and `rand` are mutually exclusive.
+
 ## Example usage
 
 The `defined` option is only necessary when you have `--order rand` stored in a
@@ -20,4 +26,5 @@ config file (e.g. `.rspec`) and you want to override it from the command line.
 --order rand
 --order rand:123
 --seed 123 # same as --order rand:123
+--order recently-modified
 </code></pre>

data/rspec-core/upstream/features/command_line/pattern_option.feature

@@ -1,8 +1,11 @@
 Feature: `--pattern` option
 
-  By default, RSpec loads files matching the pattern:
+  When you run RSpec without giving it specific file names, it determines which
+  files to load by applying a pattern to the provided directory arguments or
+  `spec` (if no directories are provided). By default, RSpec uses the following
+  pattern:
 
-      "spec/**/*_spec.rb"
+      "**{,/*/**}/*_spec.rb"
 
   Use the `--pattern` option to declare a different pattern.
 
@@ -25,7 +28,7 @@ Feature: `--pattern` option
       end
       """
 
-  Scenario: By default, RSpec runs files that match `"**/*_spec.rb"`
+  Scenario: By default, RSpec runs matching spec files
    When I run `rspec`
    Then the output should contain "2 examples, 0 failures"