rspec 1.2.4 → 1.2.5

data/lib/spec/example/example_group_factory.rb

@@ -3,6 +3,8 @@ module Spec
     
     class ExampleGroupFactory
       module ClassMethods
+        include Spec::Example::ArgsAndOptions
+        
         def reset
           @example_group_types = nil
           default(ExampleGroup)
@@ -23,8 +25,8 @@ module Spec
         end
         
         def create_example_group(*args, &block)
-          raise ArgumentError if args.empty?
-          raise ArgumentError unless block
+          raise ArgumentError if args.empty? || block.nil?
+          add_options(args)
           superclass = determine_superclass(args.last)
           superclass.describe(*args, &block)
         end

data/lib/spec/example/example_group_methods.rb

@@ -19,7 +19,11 @@ module Spec
       include Spec::Example::PredicateMatchers
       include Spec::Example::ArgsAndOptions
 
-      attr_reader :options, :location
+      attr_reader :location
+      
+      def options # :nodoc:
+        @options ||= {}
+      end
       
       def inherited(klass) # :nodoc:
         super

data/lib/spec/example/example_group_proxy.rb

@@ -10,8 +10,16 @@ module Spec
         @examples            = example_group.example_proxies
         @location            = example_group.location
         @backtrace           = example_group.location # deprecated - see the backtrace method below
+        @options             = example_group.options.dup
+        @options.delete(:location)
+        @options.delete(:scope)
       end
       
+      # Optional hash passed to the example group declaration. Note that RSpec uses
+      # this hash internally and reserves the keys :location and :scope for its own
+      # use (and removes them from this hash)
+      attr_reader :options
+      
       # This is the description passed to the <tt>describe()</tt> method or any
       # of its aliases
       attr_reader :description

data/lib/spec/example/example_matcher.rb

@@ -7,10 +7,9 @@ module Spec
       end
       
       def matches?(specified_examples)
-        specified_examples.each do |specified_example|
-          return true if matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
+        specified_examples.any? do |specified_example|
+          matches_literal_example?(specified_example) || matches_example_not_considering_modules?(specified_example)
         end
-        false
       end
       
       protected

data/lib/spec/example/example_methods.rb

@@ -30,7 +30,6 @@ module Spec
       end
 
       def execute(run_options, instance_variables) # :nodoc:
-        puts caller unless caller(0)[1] =~ /example_group_methods/
         run_options.reporter.example_started(@_proxy)
         set_instance_variables_from_hash(instance_variables)
         
@@ -52,6 +51,20 @@ module Spec
         run_options.reporter.example_finished(@_proxy.update(description), execution_error)
         success = execution_error.nil? || ExamplePendingError === execution_error
       end
+      
+      module BlockAliases
+        alias_method :to,     :should
+        alias_method :to_not, :should_not
+      end
+      
+      # Extends the submitted block with aliases to and to_not
+      # for should and should_not. Allows expectations like this:
+      #
+      #   expect { this_block }.to change{this.expression}.from(old_value).to(new_value)
+      #   expect { this_block }.to raise_error
+      def expect(&block)
+        block.extend BlockAliases
+      end
 
       def eval_each_fail_fast(blocks) # :nodoc:
         blocks.each {|block| instance_eval(&block)}

data/lib/spec/example/example_proxy.rb

@@ -8,14 +8,13 @@ module Spec
         @description, @options, @location = description, options, location
       end
       
+      # Optional hash passed to the example declaration
+      attr_reader :options
+
       # This is the docstring passed to the <tt>it()</tt> method or any
       # of its aliases
       attr_reader :description
       
-      # Internal use only - used to store options to pass to example
-      # when it is initialized
-      attr_reader :options # :nodoc:
-
       # The file and line number at which the represented example
       # was declared. This is extracted from <tt>caller</tt>, and is therefore
       # formatted as an individual line in a backtrace.

data/lib/spec/example/subject.rb

@@ -16,18 +16,18 @@ module Spec
         # See +ExampleMethods#should+ for more information about this approach.
         def subject(&block)
           block.nil? ?
-            explicit_subject || implicit_subject : @_explicit_subject_block = block
+            explicit_subject || implicit_subject : @explicit_subject_block = block
         end
         
+        attr_reader :explicit_subject_block # :nodoc:
+        
       private
       
         def explicit_subject
-          if defined?(@_explicit_subject_block)
-            @_explicit_subject_block
-          elsif super_subject = superclass.instance_variable_get('@_explicit_subject_block')
-            super_subject
-          else
-            nil
+          group = self
+          while group.respond_to?(:explicit_subject_block)
+            return group.explicit_subject_block if group.explicit_subject_block
+            group = group.superclass
           end
         end
         

data/lib/spec/interop/test.rb

@@ -1,8 +1,9 @@
+require 'spec'
+
 if Spec::Ruby.version.to_f >= 1.9
   gem 'test-unit','1.2.3'
 end
 
-require 'spec'
 require 'test/unit'
 require 'test/unit/testresult'
 

data/lib/spec/matchers/be_close.rb

@@ -10,21 +10,21 @@ module Spec
     #
     #   result.should be_close(3.0, 0.5)
     def be_close(expected, delta)
-      Matcher.new :be_close, expected, delta do |expected, delta|
+      Matcher.new :be_close, expected, delta do |_expected_, _delta_|
         match do |actual|
-          (actual - expected).abs < delta
+          (actual - _expected_).abs < _delta_
         end
 
         failure_message_for_should do |actual|
-          "expected #{expected} +/- (< #{delta}), got #{actual}"
+          "expected #{_expected_} +/- (< #{_delta_}), got #{actual}"
         end
 
         failure_message_for_should_not do |actual|
-          "expected #{expected} +/- (< #{delta}), got #{actual}"
+          "expected #{_expected_} +/- (< #{_delta_}), got #{actual}"
         end
 
         description do
-          "be close to #{expected} (within +- #{delta})"
+          "be close to #{_expected_} (within +- #{_delta_})"
         end
       end
     end

data/lib/spec/matchers/be_instance_of.rb

@@ -14,9 +14,9 @@ module Spec
     #   5.should_not be_instance_of(Numeric)
     #   5.should_not be_instance_of(Float)
     def be_an_instance_of(expected)
-      Matcher.new :be_an_instance_of, expected do |expected|
+      Matcher.new :be_an_instance_of, expected do |_expected_|
         match do |actual|
-          actual.instance_of?(expected)
+          actual.instance_of?(_expected_)
         end
       end
     end

data/lib/spec/matchers/be_kind_of.rb

@@ -14,9 +14,9 @@ module Spec
     #   5.should be_kind_of(Numeric)
     #   5.should_not be_kind_of(Float)
     def be_a_kind_of(expected)
-      Matcher.new :be_a_kind_of, expected do |expected|
+      Matcher.new :be_a_kind_of, expected do |_expected_|
         match do |actual|
-          actual.kind_of?(expected)
+          actual.kind_of?(_expected_)
         end
       end
     end

data/lib/spec/matchers/compatibility.rb

@@ -1,11 +1,11 @@
 Spec::Matchers.constants.each do |c|
   if Class === (klass = Spec::Matchers.const_get(c))
-    if klass.public_instance_methods.include?('failure_message_for_should')
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should',:failure_message_for_should].include?(m)}
       klass.class_eval do
         alias_method :failure_message, :failure_message_for_should
       end
     end
-    if klass.public_instance_methods.include?('failure_message_for_should_not')
+    if klass.public_instance_methods.any? {|m| ['failure_message_for_should_not',:failure_message_for_should_not].include?(m)}
       klass.class_eval do
         alias_method :negative_failure_message, :failure_message_for_should_not
       end

data/lib/spec/matchers/eql.rb

@@ -13,15 +13,15 @@ module Spec
     #   5.should eql(5)
     #   5.should_not eql(3)
     def eql(expected)
-      Matcher.new :eql, expected do |expected|
+      Matcher.new :eql, expected do |_expected_|
         match do |actual|
-          actual.eql?(expected)
+          actual.eql?(_expected_)
         end
 
         failure_message_for_should do |actual|
           <<-MESSAGE
 
-expected #{expected.inspect}
+expected #{_expected_.inspect}
      got #{actual.inspect}
 
 (compared using eql?)
@@ -31,7 +31,7 @@ MESSAGE
         failure_message_for_should_not do |actual|
           <<-MESSAGE
 
-expected #{actual.inspect} not to equal #{expected.inspect}
+expected #{actual.inspect} not to equal #{_expected_.inspect}
 
 (compared using eql?)
 MESSAGE

data/lib/spec/matchers/equal.rb

@@ -14,27 +14,37 @@ module Spec
     #   5.should equal(5) #Fixnums are equal
     #   "5".should_not equal("5") #Strings that look the same are not the same object
     def equal(expected)
-      Matcher.new :equal, expected do |expected|
+      Matcher.new :equal, expected do |_expected_|
         match do |actual|
-          actual.equal?(expected)
+          actual.equal?(_expected_)
+        end
+        
+        def inspect_object(o)
+          "#<#{o.class}:#{o.object_id}> => #{o.inspect}"
         end
         
         failure_message_for_should do |actual|
           <<-MESSAGE
 
-expected #{expected.inspect}
-     got #{actual.inspect}
-     
-(compared using equal?)
+expected #{inspect_object(_expected_)}
+     got #{inspect_object(actual)}
+
+Compared using equal?, which compares object identity,
+but expected and actual are not the same object. Use
+'actual.should == expected' if you don't care about
+object identity in this example.
+
 MESSAGE
         end
 
         failure_message_for_should_not do |actual|
           <<-MESSAGE
 
-expected #{actual.inspect} not to equal #{expected.inspect}
+expected not #{inspect_object(actual)}
+         got #{inspect_object(_expected_)}
+
+Compared using equal?, which compares object identity.
 
-(compared using equal?)
 MESSAGE
         end
       end

data/lib/spec/matchers/extensions/instance_exec.rb

@@ -1,6 +1,4 @@
-require 'spec/ruby'
-
-if ::Spec::Ruby.version < "1.8.7"
+unless respond_to?(:instance_exec)
   # based on Bounded Spec InstanceExec (Mauricio Fernandez)
   # http://eigenclass.org/hiki/bounded+space+instance_exec
   class Object

data/lib/spec/matchers/include.rb

@@ -17,13 +17,13 @@ module Spec
     #   "spread".should include("read")
     #   "spread".should_not include("red")
     def include(*expected)
-      Matcher.new :include, *expected do |*expecteds|
+      Matcher.new :include, *expected do |*_expected_|
         match do |actual|
-          helper(actual, *expecteds)
+          helper(actual, *_expected_)
         end
         
-        def helper(actual, *expecteds)
-          expecteds.each do |expected|
+        def helper(actual, *_expected_)
+          _expected_.each do |expected|
             if actual.is_a?(Hash)
               if expected.is_a?(Hash)
                 expected.each_pair do |k,v|

data/lib/spec/matchers/match.rb

@@ -10,9 +10,9 @@ module Spec
     #
     #   email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
     def match(expected)
-      Matcher.new :match, expected do |expected|
+      Matcher.new :match, expected do |_expected_|
         match do |actual|
-          actual =~ expected
+          actual =~ _expected_
         end
       end
     end

data/lib/spec/matchers/operator_matcher.rb

@@ -55,8 +55,9 @@ module Spec
 
     class PositiveOperatorMatcher < OperatorMatcher #:nodoc:
       def __delegate_operator(actual, operator, expected)
-        return true if actual.__send__(operator, expected)
-        if ['==','===', '=~'].include?(operator)
+        if actual.__send__(operator, expected)
+          true
+        elsif ['==','===', '=~'].include?(operator)
           fail_with_message("expected: #{expected.inspect},\n     got: #{actual.inspect} (using #{operator})") 
         else
           fail_with_message("expected: #{operator} #{expected.inspect},\n     got: #{operator.gsub(/./, ' ')} #{actual.inspect}")

data/lib/spec/mocks/methods.rb

@@ -17,6 +17,15 @@ module Spec
         end
       end
       
+      alias_method :stub, :stub!
+
+      def stub_chain(*methods)
+        while methods.length > 1
+          stub!(methods.shift).and_return(self)
+        end
+        stub!(methods.shift)
+      end
+      
       def received_message?(sym, *args, &block) #:nodoc:
         __mock_proxy.received_message?(sym.to_sym, *args, &block)
       end

data/lib/spec/mocks/mock.rb

@@ -7,12 +7,17 @@ module Spec
       # only) == Options:
       # * <tt>:null_object</tt> - if true, the mock object acts as a forgiving
       #   null object allowing any message to be sent to it.
-      def initialize(name, stubs_and_options={})
-        @name = name
+      def initialize(name='mock', stubs_and_options={})
+        if name.is_a?(Hash) && stubs_and_options.empty?
+          stubs_and_options = name
+          build_name_from_options stubs_and_options
+        else
+          @name = name
+        end
         @options = parse_options(stubs_and_options)
         assign_stubs(stubs_and_options)
       end
-      
+
       # This allows for comparing the mock to other objects that proxy such as
       # ActiveRecords belongs_to proxy objects. By making the other object run
       # the comparison, we're sure the call gets delegated to the proxy
@@ -24,32 +29,37 @@ module Spec
       def inspect
         "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
       end
-      
+
       def to_s
         inspect.gsub('<','[').gsub('>',']')
       end
-      
-      private
-
-        def method_missing(sym, *args, &block)
-          __mock_proxy.record_message_received(sym, args, block)
-          begin
-            return self if __mock_proxy.null_object?
-            super(sym, *args, &block)
-          rescue NameError
-            __mock_proxy.raise_unexpected_message_error sym, *args
-          end
-        end
-      
-        def parse_options(options)
-          options.has_key?(:null_object) ? {:null_object => options.delete(:null_object)} : {}
+
+    private
+
+      def method_missing(sym, *args, &block)
+        __mock_proxy.record_message_received(sym, args, block)
+        begin
+          return self if __mock_proxy.null_object?
+          super(sym, *args, &block)
+        rescue NameError
+          __mock_proxy.raise_unexpected_message_error sym, *args
         end
-        
-        def assign_stubs(stubs)
-          stubs.each_pair do |message, response|
-            stub!(message).and_return(response)
-          end
+      end
+
+      def parse_options(options)
+        options.has_key?(:null_object) ? {:null_object => options.delete(:null_object)} : {}
+      end
+
+      def assign_stubs(stubs)
+        stubs.each_pair do |message, response|
+          stub!(message).and_return(response)
         end
+      end
+
+      def build_name_from_options(options)
+        vals = options.inject([]) {|coll, pair| coll << "#{pair.first}: #{pair.last.inspect}"}
+        @name = '{' + vals.join(', ') + '}'
+      end
     end
   end
 end

data/lib/spec/mocks/proxy.rb

@@ -213,6 +213,7 @@ module Spec
       end
 
       def find_matching_expectation(sym, *args)
+        @expectations.find {|expectation| expectation.matches(sym, args) && !expectation.called_max_times?} || 
         @expectations.find {|expectation| expectation.matches(sym, args)}
       end