rspec-core 2.11.1 → 3.11.0

data/lib/rspec/core/runner.rb

@@ -1,75 +1,211 @@
 module RSpec
   module Core
+    # Provides the main entry point to run a suite of RSpec examples.
     class Runner
+      # @attr_reader
+      # @private
+      attr_reader :options, :configuration, :world
 
-      # Register an at_exit hook that runs the suite.
+      # Register an `at_exit` hook that runs the suite when the process exits.
+      #
+      # @note This is not generally needed. The `rspec` command takes care
+      #       of running examples for you without involving an `at_exit`
+      #       hook. This is only needed if you are running specs using
+      #       the `ruby` command, and even then, the normal way to invoke
+      #       this is by requiring `rspec/autorun`.
       def self.autorun
-        return if autorun_disabled? || installed_at_exit? || running_in_drb?
-        at_exit { exit run(ARGV, $stderr, $stdout).to_i unless $! }
+        if autorun_disabled?
+          RSpec.deprecate("Requiring `rspec/autorun` when running RSpec via the `rspec` command")
+          return
+        elsif installed_at_exit? || running_in_drb?
+          return
+        end
+
+        at_exit { perform_at_exit }
         @installed_at_exit = true
       end
-      AT_EXIT_HOOK_BACKTRACE_LINE = "#{__FILE__}:#{__LINE__ - 2}:in `autorun'"
 
+      # @private
+      def self.perform_at_exit
+        # Don't bother running any specs and just let the program terminate
+        # if we got here due to an unrescued exception (anything other than
+        # SystemExit, which is raised when somebody calls Kernel#exit).
+        return unless $!.nil? || $!.is_a?(SystemExit)
+
+        # We got here because either the end of the program was reached or
+        # somebody called Kernel#exit. Run the specs and then override any
+        # existing exit status with RSpec's exit status if any specs failed.
+        invoke
+      end
+
+      # Runs the suite of specs and exits the process with an appropriate exit
+      # code.
+      def self.invoke
+        disable_autorun!
+        status = run(ARGV, $stderr, $stdout).to_i
+        exit(status) if status != 0
+      end
+
+      # Run a suite of RSpec examples. Does not exit.
+      #
+      # This is used internally by RSpec to run a suite, but is available
+      # for use by any other automation tool.
+      #
+      # If you want to run this multiple times in the same process, and you
+      # want files like `spec_helper.rb` to be reloaded, be sure to load `load`
+      # instead of `require`.
+      #
+      # @param args [Array] command-line-supported arguments
+      # @param err [IO] error stream
+      # @param out [IO] output stream
+      # @return [Fixnum] exit status code. 0 if all specs passed,
+      #   or the configured failure exit code (1 by default) if specs
+      #   failed.
+      def self.run(args, err=$stderr, out=$stdout)
+        trap_interrupt
+        options = ConfigurationOptions.new(args)
+
+        if options.options[:runner]
+          options.options[:runner].call(options, err, out)
+        else
+          new(options).run(err, out)
+        end
+      end
+
+      def initialize(options, configuration=RSpec.configuration, world=RSpec.world)
+        @options       = options
+        @configuration = configuration
+        @world         = world
+      end
+
+      # Configures and runs a spec suite.
+      #
+      # @param err [IO] error stream
+      # @param out [IO] output stream
+      def run(err, out)
+        setup(err, out)
+        return @configuration.reporter.exit_early(exit_code) if RSpec.world.wants_to_quit
+
+        run_specs(@world.ordered_example_groups).tap do
+          persist_example_statuses
+        end
+      end
+
+      # Wires together the various configuration objects and state holders.
+      #
+      # @param err [IO] error stream
+      # @param out [IO] output stream
+      def setup(err, out)
+        configure(err, out)
+        return if RSpec.world.wants_to_quit
+
+        @configuration.load_spec_files
+      ensure
+        @world.announce_filters
+      end
+
+      # Runs the provided example groups.
+      #
+      # @param example_groups [Array<RSpec::Core::ExampleGroup>] groups to run
+      # @return [Fixnum] exit status code. 0 if all specs passed,
+      #   or the configured failure exit code (1 by default) if specs
+      #   failed.
+      def run_specs(example_groups)
+        examples_count = @world.example_count(example_groups)
+        examples_passed = @configuration.reporter.report(examples_count) do |reporter|
+          @configuration.with_suite_hooks do
+            if examples_count == 0 && @configuration.fail_if_no_examples
+              return @configuration.failure_exit_code
+            end
+
+            example_groups.map { |g| g.run(reporter) }.all?
+          end
+        end
+
+        exit_code(examples_passed)
+      end
+
+      # @private
+      def configure(err, out)
+        @configuration.error_stream = err
+        @configuration.output_stream = out if @configuration.output_stream == $stdout
+        @options.configure(@configuration)
+      end
+
+      # @private
       def self.disable_autorun!
         @autorun_disabled = true
       end
 
+      # @private
       def self.autorun_disabled?
         @autorun_disabled ||= false
       end
 
+      # @private
       def self.installed_at_exit?
         @installed_at_exit ||= false
       end
 
+      # @private
       def self.running_in_drb?
-        defined?(DRb) &&
-        (DRb.current_server rescue false) &&
-         DRb.current_server.uri =~ /druby\:\/\/127.0.0.1\:/
+        return false unless defined?(DRb)
+
+        server = begin
+                   DRb.current_server
+                 rescue DRb::DRbServerNotFound
+                   return false
+                 end
+
+        return false unless server && server.alive?
+
+        require 'socket'
+        require 'uri'
+
+        local_ipv4 = begin
+                       IPSocket.getaddress(Socket.gethostname)
+                     rescue SocketError
+                       return false
+                     end
+
+        ["127.0.0.1", "localhost", local_ipv4].any? { |addr| addr == URI(DRb.current_server.uri).host }
       end
 
+      # @private
       def self.trap_interrupt
-        trap('INT') do
-          exit!(1) if RSpec.wants_to_quit
-          RSpec.wants_to_quit = true
-          STDERR.puts "\nExiting... Interrupt again to exit immediately."
-        end
+        trap('INT') { handle_interrupt }
       end
 
-      # Run a suite of RSpec examples.
-      #
-      # This is used internally by RSpec to run a suite, but is available
-      # for use by any other automation tool.
-      #
-      # If you want to run this multiple times in the same process, and you
-      # want files like spec_helper.rb to be reloaded, be sure to load `load`
-      # instead of `require`.
-      #
-      # #### Parameters
-      # * +args+ - an array of command-line-supported arguments
-      # * +err+ - error stream (Default: $stderr)
-      # * +out+ - output stream (Default: $stdout)
-      #
-      # #### Returns
-      # * +Fixnum+ - exit status code (0/1)
-      def self.run(args, err=$stderr, out=$stdout)
-        trap_interrupt
-        options = ConfigurationOptions.new(args)
-        options.parse_options
-
-        if options.options[:drb]
-          require 'rspec/core/drb_command_line'
-          begin
-            DRbCommandLine.new(options).run(err, out)
-          rescue DRb::DRbConnError
-            err.puts "No DRb server is running. Running in local process instead ..."
-            CommandLine.new(options).run(err, out)
-          end
+      # @private
+      def self.handle_interrupt
+        if RSpec.world.wants_to_quit
+          exit!(1)
         else
-          CommandLine.new(options).run(err, out)
+          RSpec.world.wants_to_quit = true
+          $stderr.puts "\nRSpec is shutting down and will print the summary report... Interrupt again to force quit."
         end
-      ensure
-        RSpec.reset
+      end
+
+      # @private
+      def exit_code(examples_passed=false)
+        return @configuration.error_exit_code || @configuration.failure_exit_code if @world.non_example_failure
+        return @configuration.failure_exit_code unless examples_passed
+
+        0
+      end
+
+    private
+
+      def persist_example_statuses
+        return if @configuration.dry_run
+        return unless (path = @configuration.example_status_persistence_file_path)
+
+        ExampleStatusPersister.persist(@world.all_examples, path)
+      rescue SystemCallError => e
+        RSpec.warning "Could not write example statuses to #{path} (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

data/lib/rspec/core/sandbox.rb

@@ -0,0 +1,37 @@
+module RSpec
+  module Core
+    # A sandbox isolates the enclosed code into an environment that looks 'new'
+    # meaning globally accessed objects are reset for the duration of the
+    # sandbox.
+    #
+    # @note This module is not normally available. You must require
+    #   `rspec/core/sandbox` to load it.
+    module Sandbox
+      # Execute a provided block with RSpec global objects (configuration,
+      # world) reset.  This is used to test RSpec with RSpec.
+      #
+      # When calling this the configuration is passed into the provided block.
+      # Use this to set custom configs for your sandboxed examples.
+      #
+      # ```
+      # Sandbox.sandboxed do |config|
+      #   config.before(:context) { RSpec.current_example = nil }
+      # end
+      # ```
+      def self.sandboxed
+        orig_config  = RSpec.configuration
+        orig_world   = RSpec.world
+        orig_example = RSpec.current_example
+
+        RSpec.configuration = RSpec::Core::Configuration.new
+        RSpec.world         = RSpec::Core::World.new(RSpec.configuration)
+
+        yield RSpec.configuration
+      ensure
+        RSpec.configuration   = orig_config
+        RSpec.world           = orig_world
+        RSpec.current_example = orig_example
+      end
+    end
+  end
+end

data/lib/rspec/core/set.rb

@@ -0,0 +1,54 @@
+module RSpec
+  module Core
+    # @private
+    #
+    # We use this to replace `::Set` so we can have the advantage of
+    # constant time key lookups for unique arrays but without the
+    # potential to pollute a developers environment with an extra
+    # piece of the stdlib. This helps to prevent false positive
+    # builds.
+    #
+    class Set
+      include Enumerable
+
+      def initialize(array=[])
+        @values = {}
+        merge(array)
+      end
+
+      def empty?
+        @values.empty?
+      end
+
+      def <<(key)
+        @values[key] = true
+        self
+      end
+
+      def delete(key)
+        @values.delete(key)
+      end
+
+      def each(&block)
+        @values.keys.each(&block)
+        self
+      end
+
+      def include?(key)
+        @values.key?(key)
+      end
+
+      def merge(values)
+        values.each do |key|
+          @values[key] = true
+        end
+        self
+      end
+
+      def clear
+        @values.clear
+        self
+      end
+    end
+  end
+end

data/lib/rspec/core/shared_context.rb

@@ -7,7 +7,7 @@ module RSpec
     #
     #     module LoggedInAsAdmin
     #       extend RSpec::Core::SharedContext
-    #       before(:each) do
+    #       before(:example) do
     #         log_in_as :admin
     #       end
     #     end
@@ -17,33 +17,39 @@ module RSpec
     #       # ...
     #     end
     module SharedContext
-      include Hooks
-      include Let::ExampleGroupMethods
-
+      # @private
       def included(group)
-        [:before, :after].each do |type|
-          [:all, :each].each do |scope|
-            group.hooks[type][scope].concat hooks[type][scope]
-          end
-        end
-        _nested_group_declarations.each do |name, block, *args|
-          group.describe name, *args, &block
+        __shared_context_recordings.each do |recording|
+          recording.playback_onto(group)
         end
       end
 
-      def describe(name, *args, &block)
-        _nested_group_declarations << [name, block, *args]
+      # @private
+      def __shared_context_recordings
+        @__shared_context_recordings ||= []
       end
 
-      alias_method :context, :describe
-
-      private
+      # @private
+      Recording = Struct.new(:method_name, :args, :block) do
+        def playback_onto(group)
+          group.__send__(method_name, *args, &block)
+        end
+      end
 
-      def _nested_group_declarations
-        @_nested_group_declarations ||= []
+      # @private
+      def self.record(methods)
+        methods.each do |meth|
+          define_method(meth) do |*args, &block|
+            __shared_context_recordings << Recording.new(meth, args, block)
+          end
+        end
       end
+
+      # @private
+      record [:describe, :context] + Hooks.instance_methods(false) +
+        MemoizedHelpers::ClassMethods.instance_methods(false)
     end
   end
-
+  # @private
   SharedContext = Core::SharedContext
 end