rspec-core 3.2.3 → 3.3.0

data/lib/rspec/core/option_parser.rb

@@ -4,23 +4,36 @@ require 'optparse'
 module RSpec::Core
   # @private
   class Parser
-    def self.parse(args)
-      new.parse(args)
+    def self.parse(args, source=nil)
+      new(args).parse(source)
     end
 
-    def parse(args)
-      return {} if args.empty?
+    attr_reader :original_args
+
+    def initialize(original_args)
+      @original_args = original_args
+    end
+
+    def parse(source=nil)
+      return { :files_or_directories_to_run => [] } if original_args.empty?
+      args = original_args.dup
 
       options = args.delete('--tty') ? { :tty => true } : {}
       begin
         parser(options).parse!(args)
       rescue OptionParser::InvalidOption => e
-        abort "#{e.message}\n\nPlease use --help for a listing of valid options"
+        failure = e.message
+        failure << " (defined in #{source})" if source
+        abort "#{failure}\n\nPlease use --help for a listing of valid options"
       end
 
+      options[:files_or_directories_to_run] = args
       options
     end
 
+  private
+
+    # rubocop:disable MethodLength
     def parser(options)
       OptionParser.new do |parser|
         parser.banner = "Usage: rspec [options] [files or directories]\n\n"
@@ -51,12 +64,13 @@ module RSpec::Core
           options[:order] = "rand:#{seed}"
         end
 
-        parser.on('--fail-fast', 'Abort the run on first failure.') do |_o|
-          options[:fail_fast] = true
+        parser.on('--bisect[=verbose]', 'Repeatedly runs the suite in order to isolate the failures to the ',
+                  '  smallest reproducible case.') do |argument|
+          bisect_and_exit(argument)
         end
 
-        parser.on('--no-fail-fast', 'Do not abort the run on first failure.') do |_o|
-          options[:fail_fast] = false
+        parser.on('--[no-]fail-fast', 'Abort the run on first failure.') do |value|
+          set_fail_fast(options, value)
         end
 
         parser.on('--failure-exit-code CODE', Integer,
@@ -78,9 +92,7 @@ module RSpec::Core
         end
 
         parser.on('--init', 'Initialize your project with RSpec.') do |_cmd|
-          RSpec::Support.require_rspec_core "project_initializer"
-          ProjectInitializer.new.run
-          exit
+          initialize_project_and_exit
         end
 
         parser.separator("\n  **** Output ****\n\n")
@@ -143,14 +155,29 @@ module RSpec::Core
 
   **** Filtering/tags ****
 
-    In addition to the following options for selecting specific files, groups,
-    or examples, you can select a single example by appending the line number to
+    In addition to the following options for selecting specific files, groups, or
+    examples, you can select individual examples by appending the line number(s) to
     the filename:
 
-      rspec path/to/a_spec.rb:37
+      rspec path/to/a_spec.rb:37:87
+
+    You can also pass example ids enclosed in square brackets:
+
+      rspec path/to/a_spec.rb[1:5,1:6] # run the 5th and 6th examples/groups defined in the 1st group
 
 FILTERING
 
+        parser.on('--only-failures', "Filter to just the examples that failed the last time they ran.") do
+          configure_only_failures(options)
+        end
+
+        parser.on("--next-failure", "Apply `--only-failures` and abort after one failure.",
+                  "  (Equivalent to `--only-failures --fail-fast --order defined`)") do
+          configure_only_failures(options)
+          set_fail_fast(options, true)
+          options[:order] ||= 'defined'
+        end
+
         parser.on('-P', '--pattern PATTERN', 'Load files matching pattern (default: "spec/**/*_spec.rb").') do |o|
           options[:pattern] = o
         end
@@ -175,18 +202,19 @@ FILTERING
           name, value = tag.gsub(/^(~@|~|@)/, '').split(':', 2)
           name = name.to_sym
 
-          options[filter_type] ||= {}
-          options[filter_type][name] = case value
-                                       when  nil        then true # The default value for tags is true
-                                       when 'true'      then true
-                                       when 'false'     then false
-                                       when 'nil'       then nil
-                                       when /^:/        then value[1..-1].to_sym
-                                       when /^\d+$/     then Integer(value)
-                                       when /^\d+.\d+$/ then Float(value)
-                                       else
-                                         value
-                                       end
+          parsed_value = case value
+                         when  nil        then true # The default value for tags is true
+                         when 'true'      then true
+                         when 'false'     then false
+                         when 'nil'       then nil
+                         when /^:/        then value[1..-1].to_sym
+                         when /^\d+$/     then Integer(value)
+                         when /^\d+.\d+$/ then Float(value)
+                         else
+                           value
+                         end
+
+          add_tag_filter(options, filter_type, name, parsed_value)
         end
 
         parser.on('--default-path PATH', 'Set the default path where RSpec looks for examples (can',
@@ -197,8 +225,7 @@ FILTERING
         parser.separator("\n  **** Utility ****\n\n")
 
         parser.on('-v', '--version', 'Display the version.') do
-          puts RSpec::Core::Version::STRING
-          exit
+          print_version_and_exit
         end
 
         # These options would otherwise be confusing to users, so we forcibly
@@ -210,9 +237,7 @@ FILTERING
         invalid_options = %w[-d --I]
 
         parser.on_tail('-h', '--help', "You're looking at it.") do
-          # Removing the blank invalid options from the output.
-          puts parser.to_s.gsub(/^\s+(#{invalid_options.join('|')})\s*$\n/, '')
-          exit
+          print_help_and_exit(parser, invalid_options)
         end
 
         # This prevents usage of the invalid_options.
@@ -224,5 +249,53 @@ FILTERING
 
       end
     end
+    # rubocop:enable MethodLength
+
+    def add_tag_filter(options, filter_type, tag_name, value=true)
+      (options[filter_type] ||= {})[tag_name] = value
+    end
+
+    def set_fail_fast(options, value)
+      options[:fail_fast] = value
+    end
+
+    def configure_only_failures(options)
+      options[:only_failures] = true
+      add_tag_filter(options, :inclusion_filter, :last_run_status, 'failed')
+    end
+
+    def initialize_project_and_exit
+      RSpec::Support.require_rspec_core "project_initializer"
+      ProjectInitializer.new.run
+      exit
+    end
+
+    def bisect_and_exit(argument)
+      RSpec::Support.require_rspec_core "bisect/coordinator"
+
+      success = Bisect::Coordinator.bisect_with(
+        original_args,
+        RSpec.configuration,
+        bisect_formatter_for(argument)
+      )
+
+      exit(success ? 0 : 1)
+    end
+
+    def bisect_formatter_for(argument)
+      return Formatters::BisectDebugFormatter if argument == "verbose"
+      Formatters::BisectProgressFormatter
+    end
+
+    def print_version_and_exit
+      puts RSpec::Core::Version::STRING
+      exit
+    end
+
+    def print_help_and_exit(parser, invalid_options)
+      # Removing the blank invalid options from the output.
+      puts parser.to_s.gsub(/^\s+(#{invalid_options.join('|')})\s*$\n/, '')
+      exit
+    end
   end
 end

data/lib/rspec/core/ordering.rb

@@ -1,14 +1,5 @@
 module RSpec
   module Core
-    if defined?(::Random)
-      # @private
-      RandomNumberGenerator = ::Random
-    else
-      RSpec::Support.require_rspec_core "backport_random"
-      # @private
-      RandomNumberGenerator = RSpec::Core::Backports::Random
-    end
-
     # @private
     module Ordering
       # @private
@@ -33,26 +24,38 @@ module RSpec
 
         def order(items)
           @used = true
-          rng = RandomNumberGenerator.new(@configuration.seed)
-          shuffle items, rng
+
+          seed = @configuration.seed.to_s
+          items.sort_by { |item| jenkins_hash_digest(seed + item.id) }
         end
 
-        if RUBY_VERSION > '1.9.3'
-          def shuffle(list, rng)
-            list.shuffle(:random => rng)
-          end
-        else
-          def shuffle(list, rng)
-            shuffled = list.dup
-            shuffled.size.times do |i|
-              j = i + rng.rand(shuffled.size - i)
-              next if i == j
-              shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
-            end
-
-            shuffled
+      private
+
+        # http://en.wikipedia.org/wiki/Jenkins_hash_function
+        # Jenkins provides a good distribution and is simpler than MD5.
+        # It's a bit slower than MD5 (primarily because `Digest::MD5` is
+        # implemented in C) but has the advantage of not requiring us
+        # to load another part of stdlib, which we try to minimize.
+        def jenkins_hash_digest(string)
+          hash = 0
+
+          string.each_byte do |byte|
+            hash += byte
+            hash &= MAX_32_BIT
+            hash += ((hash << 10) & MAX_32_BIT)
+            hash &= MAX_32_BIT
+            hash ^= hash >> 6
           end
+
+          hash += ((hash << 3) & MAX_32_BIT)
+          hash &= MAX_32_BIT
+          hash ^= hash >> 11
+          hash += ((hash << 15) & MAX_32_BIT)
+          hash &= MAX_32_BIT
+          hash
         end
+
+        MAX_32_BIT = 4_294_967_295
       end
 
       # @private

data/lib/rspec/core/profiler.rb

@@ -0,0 +1,32 @@
+module RSpec
+  module Core
+    # @private
+    class Profiler
+      NOTIFICATIONS = [:example_group_started, :example_group_finished, :example_started]
+
+      def initialize
+        @example_groups = Hash.new { |h, k| h[k] = { :count => 0 } }
+      end
+
+      attr_reader :example_groups
+
+      def example_group_started(notification)
+        return unless notification.group.top_level?
+
+        @example_groups[notification.group][:start] = Time.now
+        @example_groups[notification.group][:description] = notification.group.top_level_description
+      end
+
+      def example_group_finished(notification)
+        return unless notification.group.top_level?
+
+        @example_groups[notification.group][:total_time] =  Time.now - @example_groups[notification.group][:start]
+      end
+
+      def example_started(notification)
+        group = notification.example.example_group.parent_groups.last
+        @example_groups[group][:count] += 1
+      end
+    end
+  end
+end

data/lib/rspec/core/project_initializer/spec/spec_helper.rb

@@ -50,10 +50,15 @@ RSpec.configure do |config|
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
 
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
   # Limits the available syntax to the non-monkey patched syntax that is
   # recommended. For more details, see:
   #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
   #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
   config.disable_monkey_patching!
 

data/lib/rspec/core/rake_task.rb

@@ -1,6 +1,7 @@
 require 'rake'
 require 'rake/tasklib'
 require 'rspec/support/ruby_features'
+require 'rspec/core/shell_escape'
 
 module RSpec
   module Core
@@ -9,6 +10,7 @@ module RSpec
     # @see Rakefile
     class RakeTask < ::Rake::TaskLib
       include ::Rake::DSL if defined?(::Rake::DSL)
+      include RSpec::Core::ShellEscape
 
       # Default path to the RSpec executable.
       DEFAULT_RSPEC_PATH = File.expand_path('../../../../exe/rspec', __FILE__)
@@ -63,16 +65,12 @@ module RSpec
       # @private
       def run_task(verbose)
         command = spec_command
+        puts command if verbose
 
-        begin
-          puts command if verbose
-          success = system(command)
-        rescue
-          puts failure_message if failure_message
-        end
-
-        return unless fail_on_error && !success
+        return if system(command)
+        puts failure_message if failure_message
 
+        return unless fail_on_error
         $stderr.puts "#{command} failed" if verbose
         exit $?.exitstatus
       end
@@ -126,18 +124,6 @@ module RSpec
         end
       end
 
-      if RSpec::Support::OS.windows?
-        def escape(shell_command)
-          "'#{shell_command.gsub("'", "\'")}'"
-        end
-      else
-        require 'shellwords'
-
-        def escape(shell_command)
-          shell_command.shellescape
-        end
-      end
-
       def file_exclusion_specification
         " --exclude-pattern #{escape exclude_pattern}" if exclude_pattern
       end

data/lib/rspec/core/reentrant_mutex.rb

@@ -0,0 +1,52 @@
+module RSpec
+  module Core
+    # Allows a thread to lock out other threads from a critical section of code,
+    # while allowing the thread with the lock to reenter that section.
+    #
+    # Based on Monitor as of 2.2 - https://github.com/ruby/ruby/blob/eb7ddaa3a47bf48045d26c72eb0f263a53524ebc/lib/monitor.rb#L9
+    #
+    # Depends on Mutex, but Mutex is only available as part of core since 1.9.1:
+    #   exists - http://ruby-doc.org/core-1.9.1/Mutex.html
+    #   dne    - http://ruby-doc.org/core-1.9.0/Mutex.html
+    #
+    # @private
+    class ReentrantMutex
+      def initialize
+        @owner = nil
+        @count = 0
+        @mutex = Mutex.new
+      end
+
+      def synchronize
+        enter
+        yield
+      ensure
+        exit
+      end
+
+    private
+
+      def enter
+        @mutex.lock if @owner != Thread.current
+        @owner = Thread.current
+        @count += 1
+      end
+
+      def exit
+        @count -= 1
+        return unless @count == 0
+        @owner = nil
+        @mutex.unlock
+      end
+    end
+
+    if defined? ::Mutex
+      # On 1.9 and up, this is in core, so we just use the real one
+      Mutex = ::Mutex
+    else # For 1.8.7
+      # :nocov:
+      RSpec::Support.require_rspec_core "mutex"
+      # :nocov:
+    end
+  end
+end

data/lib/rspec/core/reporter.rb

@@ -2,6 +2,15 @@ module RSpec::Core
   # A reporter will send notifications to listeners, usually formatters for the
   # spec suite run.
   class Reporter
+    # @private
+    RSPEC_NOTIFICATIONS = Set.new(
+      [
+        :close, :deprecation, :deprecation_summary, :dump_failures, :dump_pending,
+        :dump_profile, :dump_summary, :example_failed, :example_group_finished,
+        :example_group_started, :example_passed, :example_pending, :example_started,
+        :message, :seed, :start, :start_dump, :stop
+      ])
+
     def initialize(configuration)
       @configuration = configuration
       @listeners = Hash.new { |h, k| h[k] = Set.new }
@@ -19,6 +28,13 @@ module RSpec::Core
       @examples = []
       @failed_examples = []
       @pending_examples = []
+      @profiler = Profiler.new if defined?(@profiler)
+    end
+
+    # @private
+    def setup_profiler
+      @profiler = Profiler.new
+      register_listener @profiler, *Profiler::NOTIFICATIONS
     end
 
     # Registers a listener to a list of notifications. The reporter will send
@@ -40,7 +56,6 @@ module RSpec::Core
       @listeners[notification].to_a
     end
 
-    # @api
     # @overload report(count, &block)
     # @overload report(count, &block)
     # @param expected_example_count [Integer] the number of examples being run
@@ -73,11 +88,26 @@ module RSpec::Core
       notify :start, Notifications::StartNotification.new(expected_example_count, @load_time)
     end
 
-    # @private
+    # @param message [#to_s] A message object to send to formatters
+    #
+    # Send a custom message to supporting formatters.
     def message(message)
       notify :message, Notifications::MessageNotification.new(message)
     end
 
+    # @param event [Symbol] Name of the custom event to trigger on formatters
+    # @param options [Hash] Hash of arguments to provide via `CustomNotification`
+    #
+    # Publish a custom event to supporting registered formatters.
+    # @see RSpec::Core::Notifications::CustomNotification
+    def publish(event, options={})
+      if RSPEC_NOTIFICATIONS.include? event
+        raise "RSpec::Core::Reporter#publish is intended for sending custom " \
+              "events not internal RSpec ones, please rename your custom event."
+      end
+      notify event, Notifications::CustomNotification.for(options)
+    end
+
     # @private
     def example_group_started(group)
       notify :example_group_started, Notifications::GroupNotification.new(group) unless group.descendant_filtered_examples.empty?
@@ -118,20 +148,28 @@ module RSpec::Core
 
     # @private
     def finish
-      stop
-      notify :start_dump,    Notifications::NullNotification
-      notify :dump_pending,  Notifications::ExamplesNotification.new(self)
-      notify :dump_failures, Notifications::ExamplesNotification.new(self)
-      notify :deprecation_summary, Notifications::NullNotification
-      unless mute_profile_output?
-        notify :dump_profile, Notifications::ProfileNotification.new(@duration, @examples,
-                                                                     @configuration.profile_examples)
+      close_after do
+        stop
+        notify :start_dump,    Notifications::NullNotification
+        notify :dump_pending,  Notifications::ExamplesNotification.new(self)
+        notify :dump_failures, Notifications::ExamplesNotification.new(self)
+        notify :deprecation_summary, Notifications::NullNotification
+        unless mute_profile_output?
+          notify :dump_profile, Notifications::ProfileNotification.new(@duration, @examples,
+                                                                       @configuration.profile_examples,
+                                                                       @profiler.example_groups)
+        end
+        notify :dump_summary, Notifications::SummaryNotification.new(@duration, @examples, @failed_examples,
+                                                                     @pending_examples, @load_time)
+        notify :seed, Notifications::SeedNotification.new(@configuration.seed, seed_used?)
       end
-      notify :dump_summary, Notifications::SummaryNotification.new(@duration, @examples, @failed_examples,
-                                                                   @pending_examples, @load_time)
-      notify :seed, Notifications::SeedNotification.new(@configuration.seed, seed_used?)
+    end
+
+    # @private
+    def close_after
+      yield
     ensure
-      notify :close, Notifications::NullNotification
+      close
     end
 
     # @private
@@ -147,8 +185,19 @@ module RSpec::Core
       end
     end
 
+    # @private
+    def abort_with(msg, exit_status)
+      message(msg)
+      close
+      exit!(exit_status)
+    end
+
   private
 
+    def close
+      notify :close, Notifications::NullNotification
+    end
+
     def mute_profile_output?
       # Don't print out profiled info if there are failures and `--fail-fast` is
       # used, it just clutters the output.
@@ -163,10 +212,9 @@ module RSpec::Core
   # @private
   # # Used in place of a {Reporter} for situations where we don't want reporting output.
   class NullReporter
-  private
-
-    def method_missing(*)
+    def self.method_missing(*)
       # ignore
     end
+    private_class_method :method_missing
   end
 end