rspec-core 2.99.2 → 3.0.0.beta1

data/features/mock_framework_integration/use_flexmock.feature

@@ -88,7 +88,7 @@ Feature: mock with flexmock
 
       describe "RSpec.configuration.mock_framework.framework_name" do
         it "returns :flexmock" do
-          RSpec.configuration.mock_framework.framework_name.should eq(:flexmock)
+          expect(RSpec.configuration.mock_framework.framework_name).to eq(:flexmock)
         end
       end
       """

data/features/mock_framework_integration/use_mocha.feature

@@ -88,7 +88,7 @@ Feature: mock with mocha
 
       describe "RSpec.configuration.mock_framework.framework_name" do
         it "returns :mocha" do
-          RSpec.configuration.mock_framework.framework_name.should eq(:mocha)
+          expect(RSpec.configuration.mock_framework.framework_name).to eq(:mocha)
         end
       end
       """

data/features/mock_framework_integration/use_rr.feature

@@ -88,7 +88,7 @@ Feature: mock with rr
 
       describe "RSpec.configuration.mock_framework.framework_name" do
         it "returns :rr" do
-          RSpec.configuration.mock_framework.framework_name.should eq(:rr)
+          expect(RSpec.configuration.mock_framework.framework_name).to eq(:rr)
         end
       end
       """

data/features/mock_framework_integration/use_rspec.feature

@@ -13,7 +13,7 @@ Feature: mock with rspec
       describe "mocking with RSpec" do
         it "passes when it should" do
           receiver = double('receiver')
-          receiver.should_receive(:message)
+          expect(receiver).to receive(:message)
           receiver.message
         end
       end
@@ -31,7 +31,7 @@ Feature: mock with rspec
       describe "mocking with RSpec" do
         it "fails when it should" do
           receiver = double('receiver')
-          receiver.should_receive(:message)
+          expect(receiver).to receive(:message)
         end
       end
       """
@@ -49,7 +49,7 @@ Feature: mock with rspec
         it "is listed as pending" do
           pending do
             receiver = double('receiver')
-            receiver.should_receive(:message)
+            expect(receiver).to receive(:message)
           end
         end
       end
@@ -69,7 +69,7 @@ Feature: mock with rspec
         it "fails with FIXED" do
           pending do
             receiver = double('receiver')
-            receiver.should_receive(:message)
+            expect(receiver).to receive(:message)
             receiver.message
           end
         end
@@ -89,7 +89,7 @@ Feature: mock with rspec
 
       describe "RSpec.configuration.mock_framework.framework_name" do
         it "returns :rspec" do
-          RSpec.configuration.mock_framework.framework_name.should eq(:rspec)
+          expect(RSpec.configuration.mock_framework.framework_name).to eq(:rspec)
         end
       end
       """

data/features/pending/pending_examples.feature

@@ -65,7 +65,7 @@ Feature: pending examples
       describe "an example" do
         it "is implemented but waiting" do
           pending("something else getting finished") do
-            true.should be(true)
+            expect(true).to be(true)
           end
         end
       end
@@ -113,7 +113,7 @@ Feature: pending examples
       """ruby
       describe "an example" do
         it "checks something" do
-          (3+4).should eq(7)
+          expect(3+4).to eq(7)
         end
         specify do
           pending
@@ -135,10 +135,10 @@ Feature: pending examples
       """ruby
       describe "an example" do
         it "checks something" do
-          (3+4).should eq(7)
+          expect(3+4).to eq(7)
         end
         pending do
-          "string".reverse.should eq("gnirts")
+          expect("string".reverse).to eq("gnirts")
         end
       end
       """
@@ -176,7 +176,7 @@ Feature: pending examples
       end
 
       describe "a passing spec" do
-        def run_test; true.should be(true); end
+        def run_test; expect(true).to be(true); end
 
         it "fails when pending with a true :if condition" do
           pending("true :if", :if => true) { run_test }

data/features/spec_files/arbitrary_file_suffix.feature

@@ -5,7 +5,7 @@ Feature: arbitrary file suffix
       """ruby
       describe "something" do
         it "does something" do
-          3.should eq(3)
+          expect(3).to eq(3)
         end
       end
       """

data/features/step_definitions/additional_cli_steps.rb

@@ -8,7 +8,7 @@ end
 
 Then /^the output should not contain any of these:$/ do |table|
   table.raw.flatten.each do |string|
-    all_output.should_not =~ regexp(string)
+    expect(all_output).not_to match(regexp(string))
   end
 end
 
@@ -17,7 +17,7 @@ Then /^the output should contain one of the following:$/ do |table|
     all_output =~ regexp(string)
   end
 
-  matching_output.should have(1).item
+  expect(matching_output.count).to eq(1)
 end
 
 Then /^the example(?:s)? should(?: all)? pass$/ do
@@ -38,7 +38,7 @@ Then /^the backtrace\-normalized output should contain:$/ do |partial_output|
     line =~ /(^\s+# [^:]+:\d+)/ ? $1 : line # http://rubular.com/r/zDD7DdWyzF
   end.join("\n")
 
-  normalized_output.should =~ regexp(partial_output)
+  expect(normalized_output).to match(regexp(partial_output))
 end
 
 # This step can be generalized if it's ever used to test other colors

data/features/subject/explicit_subject.feature

@@ -13,7 +13,7 @@ Feature: explicit subject
       describe Array, "with some elements" do
         subject { [1,2,3] }
         it "should have the prescribed elements" do
-          subject.should == [1,2,3]
+          expect(subject).to eq([1,2,3])
         end
       end
       """
@@ -27,7 +27,7 @@ Feature: explicit subject
         subject { [1,2,3] }
         describe "with some elements" do
           it "should have the prescribed elements" do
-            subject.should == [1,2,3]
+            expect(subject).to eq([1,2,3])
           end
         end
       end
@@ -42,7 +42,7 @@ Feature: explicit subject
         subject { [] }
         before { subject.push(1,2,3) }
         it "should have the prescribed elements" do
-          subject.should == [1,2,3]
+          expect(subject).to eq([1,2,3])
         end
       end
       """
@@ -57,7 +57,7 @@ Feature: explicit subject
         subject { prepared_array }
         describe "with some elements" do
           it "should have the prescribed elements" do
-            subject.should == [1,2,3]
+            expect(subject).to eq([1,2,3])
           end
         end
       end
@@ -71,9 +71,9 @@ Feature: explicit subject
       describe Array do
         describe "#[]" do
           context "with index out of bounds" do
-            before { Array.should_receive(:one_two_three).once.and_return([1,2,3]) }
+            before { expect(Array).to receive(:one_two_three).once.and_return([1,2,3]) }
             subject { Array.one_two_three[42] }
-            it { is_expected.to be_nil }
+            it { should be_nil }
           end
         end
       end
@@ -89,10 +89,10 @@ Feature: explicit subject
           let(:prepared_array) { [1,2,3] }
           subject! { prepared_array.pop }
           it "removes the last value from the array" do
-            prepared_array.should eq([1,2])
+            expect(prepared_array).to eq([1,2])
           end
           it "returns the last value of the array" do
-            subject.should eq(3)
+            expect(subject).to eq(3)
           end
         end
       end

data/features/subject/implicit_receiver.feature

@@ -0,0 +1,29 @@
+Feature: implicit receiver
+
+  When `should` is called in an example without an explicit receiver, it is
+  invoked against the subject (explicit or implicit).
+
+  Scenario: implicit subject
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe Array do
+        describe "when first created" do
+          it { should be_empty }
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: explicit subject
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe Array do
+        describe "with 3 items" do
+          subject { [1,2,3] }
+          it { should_not be_empty }
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass

data/features/subject/implicit_subject.feature

@@ -12,7 +12,7 @@ Feature: implicitly defined subject
       """ruby
       describe Array do
         it "should be empty when first created" do
-          subject.should be_empty
+          expect(subject).to be_empty
         end
       end
       """
@@ -25,7 +25,7 @@ Feature: implicitly defined subject
       describe Array do
         describe "when first created" do
           it "should be empty" do
-            subject.should be_empty
+            expect(subject).to be_empty
           end
         end
       end
@@ -47,13 +47,13 @@ Feature: implicitly defined subject
         describe ArrayWithOneElement do
           context "referenced as subject" do
             it "should be empty (because it is the Array declared at the top)" do
-              subject.should be_empty
+              expect(subject).to be_empty
             end
           end
 
           context "created in the example" do
             it "should not be empty" do
-              ArrayWithOneElement.new.should_not be_empty
+              expect(ArrayWithOneElement.new).not_to be_empty
             end
           end
         end

data/features/support/env.rb

@@ -1,9 +1,11 @@
 require 'aruba/cucumber'
 
-timeouts = { 'java' => 60 }
-
 Before do
-  @aruba_timeout_seconds = timeouts.fetch(RUBY_PLATFORM) { 10 }
+  if RUBY_PLATFORM =~ /java/ || defined?(Rubinius)
+    @aruba_timeout_seconds = 60
+  else
+    @aruba_timeout_seconds = 10
+  end
 end
 
 Aruba.configure do |config|
@@ -12,3 +14,8 @@ Aruba.configure do |config|
   end
 end if RUBY_PLATFORM == 'java'
 
+Aruba.configure do |config|
+  config.before_cmd do |cmd|
+    set_env('RBXOPT', "-Xint=true #{ENV['RBXOPT']}") # disable JIT since these processes are so short lived
+  end
+end if defined?(Rubinius)

data/features/support/require_expect_syntax_in_aruba_specs.rb

@@ -0,0 +1,16 @@
+if defined?(Cucumber)
+  require 'shellwords'
+  Before do
+    set_env('SPEC_OPTS', "-r#{Shellwords.escape(__FILE__)}")
+  end
+else
+  RSpec.configure do |rspec|
+    rspec.mock_with :rspec do |mocks|
+      mocks.syntax = :expect
+    end
+
+    rspec.expect_with :rspec do |expectations|
+      expectations.syntax = :expect
+    end
+  end
+end

data/lib/rspec/core.rb

@@ -11,27 +11,27 @@ end
 require 'set'
 require 'time'
 require 'rbconfig'
-require_rspec['core/caller_filter']
+
+require_rspec['core/version']
+
+require 'rspec/support/caller_filter'
+require 'rspec/core/warnings'
+require 'rspec/support/warnings'
+
+require_rspec['core/flat_map']
 require_rspec['core/filter_manager']
 require_rspec['core/dsl']
-require_rspec['core/extensions/kernel']
-require_rspec['core/extensions/instance_eval_with_args']
-require_rspec['core/extensions/module_eval_with_args']
-require_rspec['core/extensions/ordered']
-require_rspec['core/deprecation']
-require_rspec['core/backward_compatibility']
 require_rspec['core/reporter']
 
-require_rspec['core/metadata_hash_builder']
 require_rspec['core/hooks']
 require_rspec['core/memoized_helpers']
 require_rspec['core/metadata']
 require_rspec['core/pending']
 require_rspec['core/formatters']
+require_rspec['core/ordering']
 
 require_rspec['core/world']
 require_rspec['core/configuration']
-require_rspec['core/project_initializer']
 require_rspec['core/option_parser']
 require_rspec['core/configuration_options']
 require_rspec['core/command_line']
@@ -40,19 +40,10 @@ require_rspec['core/example']
 require_rspec['core/shared_example_group/collection']
 require_rspec['core/shared_example_group']
 require_rspec['core/example_group']
-require_rspec['core/version']
 
 module RSpec
   autoload :SharedContext, 'rspec/core/shared_context'
 
-  class << self
-    # @private
-    # Counts the number of times RSpec.reset needs to be called to prevent
-    # a warning about reset's no longer being implicitly invoked.
-    attr_accessor :resets_required
-    RSpec.resets_required = 0
-  end
-
   # @private
   def self.wants_to_quit
   # Used internally to determine what to do when a SIGINT is received
@@ -78,34 +69,9 @@ module RSpec
   end
 
   # @private
-  # Query to check if the user has called RSpec.reset
-  def self.user_has_called_reset?
-    @user_has_called_reset ||= false
-  end
-
-  # @private
-  # Warns that RSpec 3.0.0 will no longer call reset for users
-  def self.warn_about_calling_reset
-    RSpec.warn_deprecation(<<-EOD)
-Calling `RSpec::Core::Runner.run` will no longer implicitly invoke
-`RSpec.reset` as of RSpec 3.0.0. If you need RSpec to be reset between your
-calls to `RSpec::Core::Runner.run` please invoke `RSpec.reset` manually in the
-appropriate place.
-EOD
-  end
-
-  # @public
   # Used internally to ensure examples get reloaded between multiple runs in
   # the same process.
   def self.reset
-    RSpec.resets_required -= 1
-    internal_reset
-  end
-
-  # @private
-  # @see RSpec.reset
-  # Warns if the user has invoked RSpec.run twice in the same process.
-  def self.internal_reset
     @world = nil
     @configuration = nil
   end
@@ -203,15 +169,14 @@ WARNING
     # it.
     class Time
       class << self
-        define_method(:now,&::Time.method(:now))
+        define_method(:now, &::Time.method(:now))
       end
     end
 
     # @private path to executable file
     def self.path_to_executable
-      File.expand_path('../../../exe/rspec', __FILE__)
+      @path_to_executable ||= File.expand_path('../../../exe/rspec', __FILE__)
     end
-
   end
 
   MODULES_TO_AUTOLOAD = {
@@ -236,5 +201,3 @@ WARNING
     ::RSpec.const_get(name)
   end
 end
-
-require_rspec['core/backward_compatibility']

data/lib/rspec/core/backport_random.rb

@@ -0,0 +1,302 @@
+# This code was (mostly) ported from the backports gem (https://github.com/marcandre/backports).
+# The goal is to provide a random number generator in Ruby versions that do not have one.
+# This was added to support localization of random spec ordering.
+#
+# These were in multiple files in backports, but merged into one here.
+
+module RSpec
+  module Core
+    # Methods used internally by the backports.
+    module Backports
+      # Helper method to coerce a value into a specific class.
+      # Raises a TypeError if the coercion fails or the returned value
+      # is not of the right class.
+      # (from Rubinius)
+      def self.coerce_to(obj, cls, meth)
+        return obj if obj.kind_of?(cls)
+
+        begin
+          ret = obj.__send__(meth)
+        rescue Exception => e
+          raise TypeError, "Coercion error: #{obj.inspect}.#{meth} => #{cls} failed:\n" \
+                           "(#{e.message})"
+        end
+        raise TypeError, "Coercion error: obj.#{meth} did NOT return a #{cls} (was #{ret.class})" unless ret.kind_of? cls
+        ret
+      end
+
+      def self.coerce_to_int(obj)
+        coerce_to(obj, Integer, :to_int)
+      end
+
+      # Used internally to make it easy to deal with optional arguments
+      # (from Rubinius)
+      Undefined = Object.new
+
+      class Random
+        # An implementation of Mersenne Twister MT19937 in Ruby
+        class MT19937
+          STATE_SIZE = 624
+          LAST_STATE = STATE_SIZE - 1
+          PAD_32_BITS = 0xffffffff
+
+          # See seed=
+          def initialize(seed)
+            self.seed = seed
+          end
+
+          LAST_31_BITS = 0x7fffffff
+          OFFSET = 397
+
+          # Generates a completely new state out of the previous one.
+          def next_state
+            STATE_SIZE.times do |i|
+              mix = @state[i] & 0x80000000 | @state[i+1 - STATE_SIZE] & 0x7fffffff
+              @state[i] = @state[i+OFFSET - STATE_SIZE] ^ (mix >> 1)
+              @state[i] ^= 0x9908b0df if mix.odd?
+            end
+            @last_read = -1
+          end
+
+          # Seed must be either an Integer (only the first 32 bits will be used)
+          # or an Array of Integers (of which only the first 32 bits will be used)
+          #
+          # No conversion or type checking is done at this level
+          def seed=(seed)
+            case seed
+            when Integer
+              @state = Array.new(STATE_SIZE)
+              @state[0] = seed & PAD_32_BITS
+              (1..LAST_STATE).each do |i|
+                @state[i] = (1812433253 * (@state[i-1]  ^ @state[i-1]>>30) + i)& PAD_32_BITS
+              end
+              @last_read = LAST_STATE
+            when Array
+              self.seed = 19650218
+              i=1
+              j=0
+              [STATE_SIZE, seed.size].max.times do
+                @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1664525) + j + seed[j] & PAD_32_BITS
+                if (i+=1) >= STATE_SIZE
+                  @state[0] = @state[-1]
+                  i = 1
+                end
+                j = 0 if (j+=1) >= seed.size
+              end
+              (STATE_SIZE-1).times do
+                @state[i] = (@state[i] ^ (@state[i-1] ^ @state[i-1]>>30) * 1566083941) - i & PAD_32_BITS
+                if (i+=1) >= STATE_SIZE
+                  @state[0] = @state[-1]
+                  i = 1
+                end
+              end
+              @state[0] = 0x80000000
+            else
+              raise ArgumentError, "Seed must be an Integer or an Array"
+            end
+          end
+
+          # Returns a random Integer from the range 0 ... (1 << 32)
+          def random_32_bits
+            next_state if @last_read >= LAST_STATE
+            @last_read += 1
+            y = @state[@last_read]
+            # Tempering
+            y ^= (y >> 11)
+            y ^= (y << 7) & 0x9d2c5680
+            y ^= (y << 15) & 0xefc60000
+            y ^= (y >> 18)
+          end
+
+          # Supplement the MT19937 class with methods to do
+          # conversions the same way as MRI.
+          # No argument checking is done here either.
+
+          FLOAT_FACTOR = 1.0/9007199254740992.0
+          # generates a random number on [0,1) with 53-bit resolution
+          def random_float
+            ((random_32_bits >> 5) * 67108864.0 + (random_32_bits >> 6)) * FLOAT_FACTOR;
+          end
+
+          # Returns an integer within 0...upto
+          def random_integer(upto)
+            n = upto - 1
+            nb_full_32 = 0
+            while n > PAD_32_BITS
+              n >>= 32
+              nb_full_32 += 1
+            end
+            mask = mask_32_bits(n)
+            begin
+              rand = random_32_bits & mask
+              nb_full_32.times do
+                rand <<= 32
+                rand |= random_32_bits
+              end
+            end until rand < upto
+            rand
+          end
+
+          def random_bytes(nb)
+            nb_32_bits = (nb + 3) / 4
+            random = nb_32_bits.times.map { random_32_bits }
+            random.pack("L" * nb_32_bits)[0, nb]
+          end
+
+          def state_as_bignum
+            b = 0
+            @state.each_with_index do |val, i|
+              b |= val << (32 * i)
+            end
+            b
+          end
+
+          def left # It's actually the number of words left + 1, as per MRI...
+            MT19937::STATE_SIZE - @last_read
+          end
+
+          def marshal_dump
+            [state_as_bignum, left]
+          end
+
+          def marshal_load(ary)
+            b, left = ary
+            @last_read = MT19937::STATE_SIZE - left
+            @state = Array.new(STATE_SIZE)
+            STATE_SIZE.times do |i|
+              @state[i] = b & PAD_32_BITS
+              b >>= 32
+            end
+          end
+
+          # Convert an Integer seed of arbitrary size to either a single 32 bit integer, or an Array of 32 bit integers
+          def self.convert_seed(seed)
+            seed = seed.abs
+            long_values = []
+            begin
+              long_values << (seed & PAD_32_BITS)
+              seed >>= 32
+            end until seed == 0
+
+            long_values.pop if long_values[-1] == 1 && long_values.size > 1 # Done to allow any kind of sequence of integers
+
+            long_values.size > 1 ? long_values : long_values.first
+          end
+
+          def self.[](seed)
+            new(convert_seed(seed))
+          end
+
+          private
+
+          MASK_BY = [1,2,4,8,16]
+          def mask_32_bits(n)
+            MASK_BY.each do |shift|
+              n |= n >> shift
+            end
+            n
+          end
+        end
+
+        # Implementation corresponding to the actual Random class of Ruby
+        # The actual random generator (mersenne twister) is in MT19937.
+        # Ruby specific conversions are handled in bits_and_bytes.
+        # The high level stuff (argument checking) is done here.
+        module Implementation
+          attr_reader :seed
+
+          def initialize(seed = 0)
+            super()
+            seed_rand seed
+          end
+
+          def seed_rand(new_seed = 0)
+            new_seed = Backports.coerce_to_int(new_seed)
+            @seed = nil unless defined?(@seed)
+            old, @seed = @seed, new_seed.nonzero? || Random.new_seed
+            @mt = MT19937[ @seed ]
+            old
+          end
+
+          def rand(limit = Backports::Undefined)
+            case limit
+              when Backports::Undefined
+                @mt.random_float
+              when Float
+                limit * @mt.random_float unless limit <= 0
+              when Range
+                _rand_range(limit)
+              else
+                limit = Backports.coerce_to_int(limit)
+                @mt.random_integer(limit) unless limit <= 0
+            end || raise(ArgumentError, "invalid argument #{limit}")
+          end
+
+          def bytes(nb)
+            nb = Backports.coerce_to_int(nb)
+            raise ArgumentError, "negative size" if nb < 0
+            @mt.random_bytes(nb)
+          end
+
+          def ==(other)
+            other.is_a?(Random) &&
+              seed == other.seed &&
+              left == other.send(:left) &&
+              state == other.send(:state)
+          end
+
+          def marshal_dump
+            @mt.marshal_dump << @seed
+          end
+
+          def marshal_load(ary)
+            @seed = ary.pop
+            @mt = MT19937.allocate
+            @mt.marshal_load(ary)
+          end
+
+          private
+
+          def state
+            @mt.state_as_bignum
+          end
+
+          def left
+            @mt.left
+          end
+
+          def _rand_range(limit)
+            range = limit.end - limit.begin
+            if (!range.is_a?(Float)) && range.respond_to?(:to_int) && range = Backports.coerce_to_int(range)
+              range += 1 unless limit.exclude_end?
+              limit.begin + @mt.random_integer(range) unless range <= 0
+            elsif range = Backports.coerce_to(range, Float, :to_f)
+              if range < 0
+                nil
+              elsif limit.exclude_end?
+                limit.begin + @mt.random_float * range unless range <= 0
+              else
+                # cheat a bit... this will reduce the nb of random bits
+                loop do
+                  r = @mt.random_float * range * 1.0001
+                  break limit.begin + r unless r > range
+                end
+              end
+            end
+          end
+        end
+
+        def self.new_seed
+          (2 ** 62) + Kernel.rand(2 ** 62)
+        end
+      end
+
+      class Random
+        include Implementation
+        class << self
+          include Implementation
+        end
+      end
+    end
+  end
+end