rspec-core 3.7.1 → 3.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 82269549116ef3ac8ad256ce6deafa672865194fcdb4b1a194f21e29c6e2bff7
-  data.tar.gz: 20f2bac3761d3b34c947cb1214b50ef3a6b27abddb9d852857f0302a0f84cd5c
+SHA1:
+  metadata.gz: 01f0ed2875b8c4e0801d2857936e4a4116ceb309
+  data.tar.gz: 58b9a780de52779ef48a2c510d99c14dd7a22f1d
 SHA512:
-  metadata.gz: 2acb4568e22713e22debbf548052112e903af5297c6ec8e8be9b9c8c2c657b79eb9c7a2c83efcf9d4366c40f7134bf77ca7eea3ba8f82dd36ac9a554a744e04e
-  data.tar.gz: 9b88592b83c97d497774f0b47fa837c895ffabd7c0e52806d3f8c773c505110e6b1f6f1fa8ae348b1533fde353d07fa803cc1c21511d27748e61147dbd505423
+  metadata.gz: dc81061f5a9badff82a346285c6571447b9884906540c0502aeec96c1d100d4c764e2422f87dadd46148a8db96926b9c1a5e5d57a72adda28d6f05ddceae65e9
+  data.tar.gz: 940193670454593373c80e55c407e31a70b3eb8f9579b108663ec9234e2025149a93aed2d8aec8e2e7eeffd124853bf1a5a068d2a79e4bbcaed551b769d485fd

data/Changelog.md

@@ -1,3 +1,32 @@
+### 3.8.0 / 2018-08-04
+[Full Changelog](http://github.com/rspec/rspec-core/compare/v3.7.1...v3.8.0)
+
+Enhancements:
+
+* Improve shell escaping used by `RSpec::Core::RakeTask` and `--bisect` so
+  that it works on `Pathname` objects. (Andrew Vit, #2479)
+* Nicely format errors encountered while loading files specified
+  by `--require` option.  (Myron Marston, #2504)
+* Significantly improve the performance of `--bisect` on platforms that
+  support forking by replacing the shell-based runner with one that uses
+  forking so that RSpec and the application environment can be booted only
+  once, instead of once per spec run. (Myron Marston, #2511)
+* Provide a configuration API to pick which bisect runner is used for
+  `--bisect`. Pick a runner via `config.bisect_runner = :shell` or
+  `config.bisect_runner = :fork` in a file loaded by a `--require`
+  option passed at the command line or set in `.rspec`. (Myron Marston, #2511)
+* Support the [XDG Base Directory
+  Specification](https://specifications.freedesktop.org/basedir-spec/latest/)
+  for the global options file. `~/.rspec` is still supported when no
+  options file is found in `$XDG_CONFIG_HOME/rspec/options` (Magnus Bergmark, #2538)
+* Extract `RSpec.world.prepare_example_filtering` that sets up the
+  example filtering for custom RSpec runners. (Oleg Pudeyev, #2552)
+
+Bug Fixes:
+
+* Prevent an `ArgumentError` when truncating backtraces with two identical
+  backtraces. (Systho, #2515, Benoit Tigeot, #2539)
+
 ### 3.7.1 / 2018-01-02
 [Full Changelog](http://github.com/rspec/rspec-core/compare/v3.7.0...v3.7.1)
 

data/README.md

@@ -15,7 +15,7 @@ RSpec repos as well. Add the following to your `Gemfile`:
 
 ```ruby
 %w[rspec rspec-core rspec-expectations rspec-mocks rspec-support].each do |lib|
-  gem lib, :git => "git://github.com/rspec/#{lib}.git", :branch => 'master'
+  gem lib, :git => "https://github.com/rspec/#{lib}.git", :branch => 'master'
 end
 ```
 

data/lib/rspec/core/bisect/coordinator.rb

@@ -1,62 +1,58 @@
-RSpec::Support.require_rspec_core "bisect/server"
-RSpec::Support.require_rspec_core "bisect/runner"
+RSpec::Support.require_rspec_core "bisect/shell_command"
 RSpec::Support.require_rspec_core "bisect/example_minimizer"
+RSpec::Support.require_rspec_core "bisect/utilities"
 RSpec::Support.require_rspec_core "formatters/bisect_progress_formatter"
 
 module RSpec
   module Core
     module Bisect
-      # @private
       # The main entry point into the bisect logic. Coordinates among:
-      #   - Bisect::Server: Receives suite results.
-      #   - Bisect::Runner: Runs a set of examples and directs the results
-      #     to the server.
+      #   - Bisect::ShellCommand: Generates shell commands to run spec subsets
       #   - Bisect::ExampleMinimizer: Contains the core bisect logic.
-      #   - Formatters::BisectProgressFormatter: provides progress updates
-      #     to the user.
+      #   - A bisect runner: runs a set of examples and returns the results.
+      #   - A bisect formatter: provides progress updates to the user.
+      # @private
       class Coordinator
-        def self.bisect_with(original_cli_args, configuration, formatter)
-          new(original_cli_args, configuration, formatter).bisect
+        def self.bisect_with(spec_runner, original_cli_args, formatter)
+          new(spec_runner, original_cli_args, formatter).bisect
         end
 
-        def initialize(original_cli_args, configuration, formatter)
-          @original_cli_args = original_cli_args
-          @configuration     = configuration
-          @formatter         = formatter
+        def initialize(spec_runner, original_cli_args, formatter)
+          @spec_runner   = spec_runner
+          @shell_command = ShellCommand.new(original_cli_args)
+          @notifier      = Bisect::Notifier.new(formatter)
         end
 
         def bisect
-          @configuration.add_formatter @formatter
-
-          reporter.close_after do
-            repro = Server.run do |server|
-              runner    = Runner.new(server, @original_cli_args)
-              minimizer = ExampleMinimizer.new(runner, reporter)
+          repro = start_bisect_runner do |runner|
+            minimizer = ExampleMinimizer.new(@shell_command, runner, @notifier)
 
-              gracefully_abort_on_sigint(minimizer)
-              minimizer.find_minimal_repro
-              minimizer.repro_command_for_currently_needed_ids
-            end
-
-            reporter.publish(:bisect_repro_command, :repro => repro)
+            gracefully_abort_on_sigint(minimizer)
+            minimizer.find_minimal_repro
+            minimizer.repro_command_for_currently_needed_ids
           end
 
+          @notifier.publish(:bisect_repro_command, :repro => repro)
+
           true
         rescue BisectFailedError => e
-          reporter.publish(:bisect_failed, :failure_explanation => e.message)
+          @notifier.publish(:bisect_failed, :failure_explanation => e.message)
           false
+        ensure
+          @notifier.publish(:close)
         end
 
       private
 
-        def reporter
-          @configuration.reporter
+        def start_bisect_runner(&block)
+          klass = @spec_runner.configuration.bisect_runner_class
+          klass.start(@shell_command, @spec_runner, &block)
         end
 
         def gracefully_abort_on_sigint(minimizer)
           trap('INT') do
             repro = minimizer.repro_command_for_currently_needed_ids
-            reporter.publish(:bisect_aborted, :repro => repro)
+            @notifier.publish(:bisect_aborted, :repro => repro)
             exit(1)
           end
         end

data/lib/rspec/core/bisect/example_minimizer.rb

@@ -1,3 +1,5 @@
+RSpec::Support.require_rspec_core "bisect/utilities"
+
 module RSpec
   module Core
     module Bisect
@@ -5,12 +7,13 @@ module RSpec
       # Contains the core bisect logic. Searches for examples we can ignore by
       # repeatedly running different subsets of the suite.
       class ExampleMinimizer
-        attr_reader :runner, :reporter, :all_example_ids, :failed_example_ids
+        attr_reader :shell_command, :runner, :all_example_ids, :failed_example_ids
         attr_accessor :remaining_ids
 
-        def initialize(runner, reporter)
-          @runner   = runner
-          @reporter = reporter
+        def initialize(shell_command, runner, notifier)
+          @shell_command = shell_command
+          @runner        = runner
+          @notifier      = notifier
         end
 
         def find_minimal_repro
@@ -82,7 +85,7 @@ module RSpec
         end
 
         def repro_command_for_currently_needed_ids
-          return runner.repro_command_from(currently_needed_ids) if remaining_ids
+          return shell_command.repro_command_from(currently_needed_ids) if remaining_ids
           "(Not yet enough information to provide any repro command)"
         end
 
@@ -108,7 +111,8 @@ module RSpec
         end
 
         def prep
-          notify(:bisect_starting, :original_cli_args => runner.original_cli_args)
+          notify(:bisect_starting, :original_cli_args => shell_command.original_cli_args,
+                                   :bisect_runner => runner.class.name)
 
           _, duration = track_duration do
             original_results    = runner.original_results
@@ -135,7 +139,7 @@ module RSpec
           ids_to_run = ids + failed_example_ids
           notify(
             :bisect_individual_run_start,
-            :command => runner.repro_command_from(ids_to_run),
+            :command => shell_command.repro_command_from(ids_to_run),
             :ids_to_run => ids_to_run
           )
 
@@ -161,7 +165,7 @@ module RSpec
         end
 
         def notify(*args)
-          reporter.publish(*args)
+          @notifier.publish(*args)
         end
       end
     end

data/lib/rspec/core/bisect/fork_runner.rb

@@ -0,0 +1,134 @@
+require 'stringio'
+RSpec::Support.require_rspec_core "formatters/base_bisect_formatter"
+RSpec::Support.require_rspec_core "bisect/utilities"
+
+module RSpec
+  module Core
+    module Bisect
+      # A Bisect runner that runs requested subsets of the suite by forking
+      # sub-processes. The master process bootstraps RSpec and the application
+      # environment (including preloading files specified via `--require`) so
+      # that the individual spec runs do not have to re-pay that cost.  Each
+      # spec run happens in a forked process, ensuring that the spec files are
+      # not loaded in the main process.
+      #
+      # For most projects, bisections that use `ForkRunner` instead of
+      # `ShellRunner` will finish significantly faster, because the `ShellRunner`
+      # pays the cost of booting RSpec and the app environment on _every_ run of
+      # a subset. In contrast, `ForkRunner` pays that cost only once.
+      #
+      # However, not all projects can use `ForkRunner`. Obviously, on platforms
+      # that do not support forking (e.g. Windows), it cannot be used. In addition,
+      # it can cause problems for some projects that put side-effectful spec
+      # bootstrapping logic that should run on every spec run directly at the top
+      # level in a file loaded by `--require`, rather than in a `before(:suite)`
+      # hook. For example, consider a project that relies on some top-level logic
+      # in `spec_helper` to boot a Redis server for the test suite, intending the
+      # Redis bootstrapping to happen on every spec run. With `ShellRunner`, the
+      # bootstrapping logic will happen for each run of any subset of the suite,
+      # but for `ForkRunner`, such logic will only get run once, when the
+      # `RunDispatcher` boots the application environment. This might cause
+      # problems. The solution is for users to move the bootstrapping logic into
+      # a `before(:suite)` hook, or use the slower `ShellRunner`.
+      #
+      # @private
+      class ForkRunner
+        def self.start(shell_command, spec_runner)
+          instance = new(shell_command, spec_runner)
+          yield instance
+        ensure
+          instance.shutdown
+        end
+
+        def self.name
+          :fork
+        end
+
+        def initialize(shell_command, spec_runner)
+          @shell_command = shell_command
+          @channel = Channel.new
+          @run_dispatcher = RunDispatcher.new(spec_runner, @channel)
+        end
+
+        def run(locations)
+          run_descriptor = ExampleSetDescriptor.new(locations, original_results.failed_example_ids)
+          dispatch_run(run_descriptor)
+        end
+
+        def original_results
+          @original_results ||= dispatch_run(ExampleSetDescriptor.new(
+            @shell_command.original_locations, []))
+        end
+
+        def shutdown
+          @channel.close
+        end
+
+      private
+
+        def dispatch_run(run_descriptor)
+          @run_dispatcher.dispatch_specs(run_descriptor)
+          @channel.receive.tap do |result|
+            if result.is_a?(String)
+              raise BisectFailedError.for_failed_spec_run(result)
+            end
+          end
+        end
+
+        # @private
+        class RunDispatcher
+          def initialize(runner, channel)
+            @runner = runner
+            @channel = channel
+
+            @spec_output = StringIO.new
+
+            runner.configuration.tap do |c|
+              c.reset_reporter
+              c.output_stream = @spec_output
+              c.error_stream = @spec_output
+            end
+          end
+
+          def dispatch_specs(run_descriptor)
+            pid = fork { run_specs(run_descriptor) }
+            Process.waitpid(pid)
+          end
+
+        private
+
+          def run_specs(run_descriptor)
+            $stdout = $stderr = @spec_output
+            formatter = CaptureFormatter.new(run_descriptor.failed_example_ids)
+
+            @runner.configuration.tap do |c|
+              c.files_or_directories_to_run = run_descriptor.all_example_ids
+              c.formatter = formatter
+              c.load_spec_files
+            end
+
+            # `announce_filters` has the side effect of implementing the logic
+            # that honors `config.run_all_when_everything_filtered` so we need
+            # to call it here. When we remove `run_all_when_everything_filtered`
+            # (slated for RSpec 4), we can remove this call to `announce_filters`.
+            @runner.world.announce_filters
+
+            @runner.run_specs(@runner.world.ordered_example_groups)
+            latest_run_results = formatter.results
+
+            if latest_run_results.nil? || latest_run_results.all_example_ids.empty?
+              @channel.send(@spec_output.string)
+            else
+              @channel.send(latest_run_results)
+            end
+          end
+        end
+
+        class CaptureFormatter < Formatters::BaseBisectFormatter
+          attr_accessor :results
+          alias_method :notify_results, :results=
+        end
+      end
+    end
+  end
+end

data/lib/rspec/core/bisect/server.rb

@@ -1,13 +1,11 @@
 require 'drb/drb'
 require 'drb/acl'
+RSpec::Support.require_rspec_core "bisect/utilities"
 
 module RSpec
   module Core
     # @private
     module Bisect
-      # @private
-      BisectFailedError = Class.new(StandardError)
-
       # @private
       # A DRb server that receives run results from a separate RSpec process
       # started by the bisect process.
@@ -27,7 +25,7 @@ module RSpec
           run_output = yield
 
           if latest_run_results.nil? || latest_run_results.all_example_ids.empty?
-            raise_bisect_failed(run_output)
+            raise BisectFailedError.for_failed_spec_run(run_output)
           end
 
           latest_run_results
@@ -49,21 +47,14 @@ module RSpec
           @drb_port ||= Integer(@drb.uri[/\d+$/])
         end
 
-        # Fetched via DRb by the BisectFormatter to determine when to abort.
+        # Fetched via DRb by the BisectDRbFormatter to determine when to abort.
         attr_accessor :expected_failures
 
-        # Set via DRb by the BisectFormatter with the results of the run.
+        # Set via DRb by the BisectDRbFormatter with the results of the run.
         attr_accessor :latest_run_results
 
         # Fetched via DRb to tell clients which files to run
         attr_accessor :files_or_directories_to_run
-
-      private
-
-        def raise_bisect_failed(run_output)
-          raise BisectFailedError, "Failed to get results from the spec " \
-                "run. Spec run output:\n\n#{run_output}"
-        end
       end
     end
   end

data/lib/rspec/core/bisect/{runner.rb → shell_command.rb}

@@ -1,36 +1,30 @@
 RSpec::Support.require_rspec_core "shell_escape"
-require 'open3'
 require 'shellwords'
 
 module RSpec
   module Core
     module Bisect
-      # Provides an API to run the suite for a set of locations, using
-      # the given bisect server to capture the results.
+      # Provides an API to generate shell commands to run the suite for a
+      # set of locations, using the given bisect server to capture the results.
       # @private
-      class Runner
+      class ShellCommand
         attr_reader :original_cli_args
 
-        def initialize(server, original_cli_args)
-          @server            = server
+        def initialize(original_cli_args)
           @original_cli_args = original_cli_args.reject { |arg| arg.start_with?("--bisect") }
         end
 
-        def run(locations)
-          run_locations(locations, original_results.failed_example_ids)
-        end
-
-        def command_for(locations)
+        def command_for(locations, server)
           parts = []
 
           parts << RUBY << load_path
           parts << open3_safe_escape(RSpec::Core.path_to_executable)
 
-          parts << "--format"   << "bisect"
-          parts << "--drb-port" << @server.drb_port
+          parts << "--format"   << "bisect-drb"
+          parts << "--drb-port" << server.drb_port
 
-          parts.concat reusable_cli_options
-          parts.concat locations.map { |l| open3_safe_escape(l) }
+          parts.concat(reusable_cli_options)
+          parts.concat(locations.map { |l| open3_safe_escape(l) })
 
           parts.join(" ")
         end
@@ -46,8 +40,24 @@ module RSpec
           parts.join(" ")
         end
 
-        def original_results
-          @original_results ||= run_locations(original_locations)
+        def original_locations
+          parsed_original_cli_options.fetch(:files_or_directories_to_run)
+        end
+
+        def bisect_environment_hash
+          if ENV.key?('SPEC_OPTS')
+            { 'SPEC_OPTS' => spec_opts_without_bisect }
+          else
+            {}
+          end
+        end
+
+        def spec_opts_without_bisect
+          Shellwords.join(
+            Shellwords.split(ENV.fetch('SPEC_OPTS', '')).reject do |arg|
+              arg =~ /^--bisect/
+            end
+          )
         end
 
       private
@@ -63,61 +73,12 @@ module RSpec
           alias open3_safe_escape escape
         end
 
-        def run_locations(*capture_args)
-          @server.capture_run_results(*capture_args) do
-            run_command command_for([])
-          end
-        end
-
-        # `Open3.capture2e` does not work on JRuby:
-        # https://github.com/jruby/jruby/issues/2766
-        if Open3.respond_to?(:capture2e) && !RSpec::Support::Ruby.jruby?
-          def run_command(cmd)
-            Open3.capture2e(bisect_environment_hash, cmd).first
-          end
-        else # for 1.8.7
-          # :nocov:
-          def run_command(cmd)
-            out = err = nil
-
-            original_spec_opts = ENV['SPEC_OPTS']
-            ENV['SPEC_OPTS'] = spec_opts_without_bisect
-
-            Open3.popen3(cmd) do |_, stdout, stderr|
-              # Reading the streams blocks until the process is complete
-              out = stdout.read
-              err = stderr.read
-            end
-
-            "Stdout:\n#{out}\n\nStderr:\n#{err}"
-          ensure
-            ENV['SPEC_OPTS'] = original_spec_opts
-          end
-          # :nocov:
-        end
-
-        def bisect_environment_hash
-          if ENV.key?('SPEC_OPTS')
-            { 'SPEC_OPTS' => spec_opts_without_bisect }
-          else
-            {}
-          end
-        end
-
         def environment_repro_parts
           bisect_environment_hash.map do |k, v|
             %Q(#{k}="#{v}")
           end
         end
 
-        def spec_opts_without_bisect
-          Shellwords.join(
-            Shellwords.split(ENV.fetch('SPEC_OPTS', '')).reject do |arg|
-              arg =~ /^--bisect/
-            end
-          )
-        end
-
         def reusable_cli_options
           @reusable_cli_options ||= begin
             opts = original_cli_args_without_locations
@@ -146,10 +107,6 @@ module RSpec
           @parsed_original_cli_options ||= Parser.parse(@original_cli_args)
         end
 
-        def original_locations
-          parsed_original_cli_options.fetch(:files_or_directories_to_run)
-        end
-
         def load_path
           @load_path ||= "-I#{$LOAD_PATH.map { |p| open3_safe_escape(p) }.join(':')}"
         end