dchelimsky-rspec 1.1.12 → 1.1.99.1

data/lib/spec/example/module_reopening_fix.rb

@@ -1,6 +1,28 @@
 module Spec
   module Example
-    # This is a fix for ...Something in Ruby 1.8.6??... (Someone fill in here please - Aslak)
+    # When you reopen a module that is included in another module that is included in a class,
+    # the new material you define does not make it to the class. This fixes that.
+    # 
+    # == Example
+    # 
+    #   module M1; end
+    # 
+    #   module M2
+    #     def foo; "FOO"; end
+    #   end
+    # 
+    #   class C
+    #     include M1
+    #   end
+    # 
+    #   module M1
+    #     include M2
+    #   end
+    # 
+    #   c = C.new
+    #   c.foo
+    #   NoMethodError: undefined method `foo' for #<C:0x5e89a4>
+    #     from (irb):12
     module ModuleReopeningFix
       def child_modules
         @child_modules ||= []

data/lib/spec/example/predicate_matchers.rb

@@ -0,0 +1,47 @@
+module Spec
+  module Example
+    module PredicateMatchers
+      # :call-seq:
+      #   predicate_matchers[matcher_name] = method_on_object
+      #   predicate_matchers[matcher_name] = [method1_on_object, method2_on_object]
+      #
+      # Dynamically generates a custom matcher that will match
+      # a predicate on your class. RSpec provides a couple of these
+      # out of the box:
+      #
+      #   exist (for state expectations)
+      #     File.should exist("path/to/file")
+      #
+      #   an_instance_of (for mock argument matchers)
+      #     mock.should_receive(:message).with(an_instance_of(String))
+      #
+      # == Examples
+      #
+      #   class Fish
+      #     def can_swim?
+      #       true
+      #     end
+      #   end
+      #
+      #   describe Fish do
+      #     predicate_matchers[:swim] = :can_swim?
+      #     it "should swim" do
+      #       Fish.new.should swim
+      #     end
+      #   end
+      def predicate_matchers
+        @predicate_matchers ||= {}
+      end
+
+      def define_methods_from_predicate_matchers # :nodoc:
+        predicate_matchers.each_pair do |matcher_method, method_on_object|
+          define_method matcher_method do |*args|
+            eval("be_#{method_on_object.to_s.gsub('?','')}(*args)")
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/spec/example/subject.rb

@@ -0,0 +1,91 @@
+module Spec
+  module Example
+    module Subject
+      module ExampleGroupMethods
+        # Defines an explicit subject for an example group which can then be the
+        # implicit receiver (through delegation) of calls to +should+.
+        #
+        # == Examples
+        #
+        #   describe CheckingAccount, "with $50" do
+        #     subject { CheckingAccount.new(:amount => 50, :currency => :USD) }
+        #     it { should have_a_balance_of(50, :USD) }
+        #     it { should_not be_overdrawn }
+        #   end
+        #
+        # See +ExampleMethods#should+ for more information about this approach.
+        def subject(&block)
+          if block.nil?
+            @_subject_block || (described_class ? lambda {described_class.new} : lambda {})
+          else
+            @_subject_block = block
+          end
+        end
+      end
+      
+      module ExampleMethods
+        # Returns the subject defined in ExampleGroupMethods#subject. The
+        # subject block is only executed once per example, the result of which
+        # is cached and returned by any subsequent calls to +subject+.
+        #
+        # If a class is passed to +describe+ and no subject is explicitly
+        # declared in the example group, then +subject+ will return a new
+        # instance of that class.
+        #
+        # == Examples
+        #
+        #   # explicit subject defined by the subject method
+        #   describe Person do
+        #     subject { Person.new(:birthdate => 19.years.ago) }
+        #     it "should be eligible to vote" do
+        #       subject.should be_eligible_to_vote
+        #     end
+        #   end
+        #
+        #   # implicit subject => { Person.new }
+        #   describe Person do
+        #     it "should be eligible to vote" do
+        #       subject.should be_eligible_to_vote
+        #     end
+        #   end
+        def subject
+          @subject ||= instance_eval(&self.class.subject)
+        end
+
+        # When +should+ is called with no explicit receiver, the call is
+        # delegated to the object returned by +subject+. Combined with
+        # an implicit subject (see +subject+), this supports very concise
+        # expressions.
+        #
+        # == Examples
+        #
+        #   describe Person do
+        #     it { should be_eligible_to_vote }
+        #   end
+        def should(matcher=nil)
+          if matcher
+            subject.should(matcher)
+          else
+            subject.should
+          end
+        end
+
+        # Just like +should+, +should_not+ delegates to the subject (implicit or
+        # explicit) of the example group.
+        #
+        # == Examples
+        #
+        #   describe Person do
+        #     it { should_not be_eligible_to_vote }
+        #   end
+        def should_not(matcher=nil)
+          if matcher
+            subject.should_not(matcher)
+          else
+            subject.should_not
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spec/example.rb

@@ -173,9 +173,13 @@ module Spec
 end
 
 require 'timeout'
+require 'spec/example/predicate_matchers'
+require 'spec/example/example_description'
+require 'spec/example/subject'
 require 'spec/example/before_and_after_hooks'
 require 'spec/example/pending'
 require 'spec/example/module_reopening_fix'
+require 'spec/example/example_group_hierarchy'
 require 'spec/example/example_group_methods'
 require 'spec/example/example_methods'
 require 'spec/example/example_group'

data/lib/spec/expectations/extensions.rb

@@ -1,2 +1 @@
 require 'spec/expectations/extensions/object'
-require 'spec/expectations/extensions/string_and_symbol'

data/lib/spec/expectations/handler.rb

@@ -22,7 +22,12 @@ module Spec
 
         return ::Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
         
-        match = matcher.matches?(actual, &block)
+        match = if matcher.respond_to?(:does_not_match?)
+                  !matcher.does_not_match?(actual, &block)
+                else
+                  matcher.matches?(actual, &block)
+                end
+        
         ::Spec::Expectations.fail_with(matcher.negative_failure_message) if match
         match
       end

data/lib/spec/expectations.rb

@@ -44,7 +44,7 @@ module Spec
     # <code>expected</code> and <code>target</code>, passes them
     # to the differ to append a diff message to the failure message.
     def self.fail_with(message, expected=nil, target=nil) # :nodoc:
-      if Array === message && message.length == 3
+      if (Array === message) & (message.length == 3)
         message, expected, target = message[0], message[1], message[2]
       end
       unless (differ.nil? || expected.nil? || target.nil?)

data/lib/spec/interop/test/unit/testcase.rb

@@ -5,8 +5,7 @@ module Test
     # This extension of the standard Test::Unit::TestCase makes RSpec
     # available from within, so that you can do things like:
     #
-    # require 'test/unit'
-    # require 'spec'
+    # require 'spec/test/unit'
     #
     # class MyTest < Test::Unit::TestCase
     #   it "should work with Test::Unit assertions" do
@@ -41,33 +40,17 @@ module Test
       before(:each) {setup}
       after(:each) {teardown}
 
-      def initialize(defined_description, options={}, &implementation)
-        @_defined_description = defined_description
-        
-        # TODO - examples fail in rspec-rails if we remove "|| pending_implementation"
-        #      - find a way to fail without it in rspec's code examples
-        @_implementation = implementation || pending_implementation
-
-        @_result = ::Test::Unit::TestResult.new
-        # @method_name is important to set here because it complies with Test::Unit's interface.
+      def initialize(description, options={}, &implementation)
+        super
         # Some Test::Unit extensions depend on @method_name being present.
-        @method_name = @_defined_description
-
-        # TODO - this is necessary to run single examples in rspec-rails, but I haven't
-        # found a good way to write a failing example just within rspec core
-        @_backtrace = caller
+        @method_name = description
+        @_result = ::Test::Unit::TestResult.new
       end
 
       def run(ignore_this_argument=nil)
         super()
       end
 
-    private
-
-      def pending_implementation
-        error = Spec::Example::NotYetImplementedError.new(caller)
-        lambda { raise(error) }
-      end
     end
   end
 end

data/lib/spec/interop/test.rb

@@ -1,3 +1,4 @@
+require 'spec'
 require 'test/unit'
 require 'test/unit/testresult'
 

data/lib/spec/matchers/be.rb

@@ -60,12 +60,7 @@ it reads really poorly.
 
       private
         def match_or_compare(actual)
-          case @expected
-          when TrueClass
-            @actual
-          else
-            @actual.__send__(comparison_method, @expected)
-          end
+          TrueClass === @expected ? @actual : @actual.__send__(comparison_method, @expected)
         end
       
         def comparison_method
@@ -87,7 +82,7 @@ it reads really poorly.
         def parse_expected(expected)
           ["be_an_","be_a_","be_"].each do |prefix|
             handling_predicate!
-            if expected.starts_with?(prefix)
+            if expected.to_s =~ /^#{prefix}/
               set_prefix(prefix)
               expected = expected.to_s.sub(prefix,"")
               [true, false, nil].each do |val|

data/lib/spec/matchers/be_close.rb

@@ -1,5 +1,24 @@
 module Spec
   module Matchers
+    
+    class BeClose
+      def initialize(expected, delta)
+        @expected, @delta = expected, delta
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        (@actual - @expected).abs < @delta
+      end
+      
+      def failure_message
+        "expected #{@expected} +/- (< #{@delta}), got #{@actual}"
+      end
+      
+      def description
+        "be close to #{@expected} (within +- #{@delta})"
+      end
+    end
 
     # :call-seq:
     #   should be_close(expected, delta)
@@ -11,11 +30,7 @@ module Spec
     #
     #   result.should be_close(3.0, 0.5)
     def be_close(expected, delta)
-      simple_matcher do |actual, matcher|
-        matcher.failure_message = "expected #{expected} +/- (< #{delta}), got #{actual}"
-        matcher.description = "be close to #{expected} (within +- #{delta})"
-        (actual - expected).abs < delta
-      end
+      BeClose.new(expected, delta)
     end
   end
 end

data/lib/spec/matchers/change.rb

@@ -5,9 +5,7 @@ module Spec
     class Change #:nodoc:
       def initialize(receiver=nil, message=nil, &block)
         @message = message || "result"
-        @value_proc = block || lambda {
-          receiver.__send__(message)
-        }
+        @value_proc = block || lambda {receiver.__send__(message)}
       end
       
       def matches?(event_proc)
@@ -84,6 +82,10 @@ MESSAGE
         @from = from
         self
       end
+      
+      def description
+        "change ##{@message}"
+      end
     end
     
     # :call-seq:

data/lib/spec/matchers/eql.rb

@@ -1,5 +1,28 @@
 module Spec
   module Matchers
+    class Eql
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @actual.eql?(@expected)
+      end
+      
+      def failure_message
+        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .eql?)", @expected, @actual
+      end
+      
+      def negative_failure_message
+        return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @actual
+      end
+      
+      def description
+        "eql #{@expected.inspect}"
+      end
+    end
+    
   
     # :call-seq:
     #   should eql(expected)
@@ -14,12 +37,7 @@ module Spec
     #   5.should eql(5)
     #   5.should_not eql(3)
     def eql(expected)
-      simple_matcher do |actual, matcher|
-        matcher.failure_message          = "expected #{expected.inspect}, got #{actual.inspect} (using .eql?)", expected, actual
-        matcher.negative_failure_message = "expected #{actual.inspect} not to equal #{expected.inspect} (using .eql?)", expected, actual
-        matcher.description              = "eql #{expected.inspect}"
-        actual.eql?(expected)
-      end
+      Eql.new(expected)
     end
   end
 end

data/lib/spec/matchers/equal.rb

@@ -1,5 +1,28 @@
 module Spec
   module Matchers
+    
+    class Equal
+      def initialize(expected)
+        @expected = expected
+      end
+      
+      def matches?(actual)
+        @actual = actual
+        @actual.equal?(@expected)
+      end
+      
+      def failure_message
+        return "expected #{@expected.inspect}, got #{@actual.inspect} (using .equal?)", @expected, @actual
+      end
+      
+      def negative_failure_message
+        return "expected #{@actual.inspect} not to equal #{@expected.inspect} (using .equal?)", @expected, @actual
+      end
+      
+      def description
+        "equal #{@expected.inspect}"
+      end
+    end
   
     # :call-seq:
     #   should equal(expected)
@@ -14,12 +37,7 @@ 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)
-      simple_matcher do |actual, matcher|
-        matcher.failure_message          = "expected #{expected.inspect}, got #{actual.inspect} (using .equal?)", expected, actual
-        matcher.negative_failure_message = "expected #{actual.inspect} not to equal #{expected.inspect} (using .equal?)", expected, actual
-        matcher.description              = "equal #{expected.inspect}"
-        actual.equal?(expected)
-      end
+      Equal.new(expected)
     end
   end
 end

data/lib/spec/matchers/exist.rb

@@ -1,16 +1,32 @@
 module Spec
   module Matchers
+
+    class Exist
+      def matches?(actual)
+        @actual = actual
+        actual.exist?
+      end
+
+      def failure_message
+        "expected #{@actual.inspect} to exist, but it doesn't."
+      end
+
+      def negative_failure_message
+        "expected #{@actual.inspect} to not exist, but it does."
+      end
+
+      def description
+        "exists"
+      end
+    end
+
     # :call-seq:
     #   should exist
     #   should_not exist
     #
     # Passes if actual.exist?
     def exist
-      simple_matcher do |actual, matcher|
-        matcher.failure_message = "expected #{actual.inspect} to exist, but it doesn't."
-        matcher.negative_failure_message = "expected #{actual.inspect} to not exist, but it does."
-        actual.exist?
-      end
+      Exist.new
     end
   end
 end

data/lib/spec/matchers/generated_descriptions.rb

@@ -38,11 +38,11 @@ or this:
 
 it { should matcher }
 
-the runner expects the matcher to have a #describe method. You should either
+the runner expects the matcher to have a #description method. You should either
 add a String to the example this matcher is being used in, or give it a
 description method. Then you won't have to suffer this lengthy warning again.
 MESSAGE
     end
   end
 end
-      
+      

data/lib/spec/matchers/has.rb

@@ -1,18 +1,35 @@
 module Spec
   module Matchers
-    def has(sym, *args) # :nodoc:
-      simple_matcher do |actual, matcher|
-        matcher.failure_message          = "expected ##{predicate(sym)}(#{args[0].inspect}) to return true, got false"
-        matcher.negative_failure_message = "expected ##{predicate(sym)}(#{args[0].inspect}) to return false, got true"
-        matcher.description              = "have key #{args[0].inspect}"
-        actual.__send__(predicate(sym), *args)
+    
+    class Has
+      
+      def initialize(expected, *args)
+        @expected, @args = expected, args
       end
-    end
+      
+      def matches?(actual)
+        actual.__send__(predicate(@expected), *@args)
+      end
+      
+      def failure_message
+        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return true, got false"
+      end
+      
+      def negative_failure_message
+        "expected ##{predicate(@expected)}(#{@args[0].inspect}) to return false, got true"
+      end
+      
+      def description
+        "have key #{@args[0].inspect}"
+      end
+    
+    private
     
-  private
-    def predicate(sym)
-      "#{sym.to_s.sub("have_","has_")}?".to_sym
+      def predicate(sym)
+        "#{sym.to_s.sub("have_","has_")}?".to_sym
+      end
+      
     end
-
+    
   end
 end

data/lib/spec/matchers/match.rb

@@ -1,5 +1,28 @@
 module Spec
   module Matchers
+    class Match
+      def initialize(expected)
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual
+        actual =~ @expected
+      end
+
+      def failure_message
+        return "expected #{@actual.inspect} to match #{@expected.inspect}", @expected, @actual
+      end
+
+      def negative_failure_message
+        return "expected #{@actual.inspect} not to match #{@expected.inspect}", @expected, @actual
+      end
+
+      def description
+        "match #{@expected.inspect}"
+      end
+    end
+    
     
     # :call-seq:
     #   should match(regexp)
@@ -10,13 +33,8 @@ module Spec
     # == Examples
     #
     #   email.should match(/^([^\s]+)((?:[-a-z0-9]+\.)+[a-z]{2,})$/i)
-    def match(regexp)
-      simple_matcher do |actual, matcher|
-        matcher.failure_message          = "expected #{actual.inspect} to match #{regexp.inspect}", regexp, actual
-        matcher.negative_failure_message = "expected #{actual.inspect} not to match #{regexp.inspect}", regexp, actual
-        matcher.description              = "match #{regexp.inspect}"
-        actual =~ regexp
-      end
+    def match(expected)
+      Match.new(expected)
     end
   end
 end

data/lib/spec/matchers/match_array.rb

@@ -11,7 +11,7 @@ module Spec
         @actual = actual        
         @extra_items = difference_between_arrays(@actual, @expected)
         @missing_items = difference_between_arrays(@expected, @actual)
-        @extra_items.empty? && @missing_items.empty?
+        @extra_items.empty? & @missing_items.empty?
       end
 
       def failure_message

data/lib/spec/matchers/method_missing.rb

@@ -1,8 +1,8 @@
 module Spec
   module Matchers
     def method_missing(sym, *args, &block) # :nodoc:
-      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
-      return has(sym, *args) if sym.starts_with?("have_")
+      return Matchers::Be.new(sym, *args) if sym.to_s =~ /^be_/
+      return Matchers::Has.new(sym, *args) if sym.to_s =~ /^have_/
       super
     end
   end

data/lib/spec/matchers/operator_matcher.rb

@@ -4,15 +4,16 @@ module Spec
     class OperatorMatcher
       class << self
         def registry
-          @registry ||= Hash.new {|h,k| h[k] = {}}
+          @registry ||= {}
         end
 
         def register(klass, operator, matcher)
+          registry[klass] ||= {}
           registry[klass][operator] = matcher
         end
 
         def get(klass, operator)
-          registry[klass][operator]
+          registry[klass] && registry[klass][operator]
         end
       end
 
@@ -25,9 +26,7 @@ module Spec
           if matcher = OperatorMatcher.get(@actual.class, operator)
             @actual.send(::Spec::Matchers.last_should, matcher.new(expected))
           else
-            ::Spec::Matchers.last_matcher = self
-            @operator, @expected = operator, expected
-            __delegate_operator(@actual, operator, expected)
+            eval_match(@actual, operator, expected)
           end
         end
       end
@@ -43,6 +42,14 @@ module Spec
       def description
         "#{@operator} #{@expected.inspect}"
       end
+      
+    private
+      
+      def eval_match(actual, operator, expected)
+        ::Spec::Matchers.last_matcher = self
+        @operator, @expected = operator, expected
+        __delegate_operator(actual, operator, expected)
+      end
 
     end
 

data/lib/spec/matchers/raise_error.rb

@@ -31,7 +31,7 @@ module Spec
           eval_block if @raised_expected_error && @with_expected_message && @block
         end
       ensure
-        return (@raised_expected_error && @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+        return (@raised_expected_error & @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
       end
       
       def eval_block

data/lib/spec/matchers/respond_to.rb

@@ -25,7 +25,6 @@ module Spec
       end
       
       def description
-        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
         "respond to #{pp_names}#{with_arity}"
       end
       
@@ -51,6 +50,7 @@ module Spec
       end
       
       def pp_names
+        # Ruby 1.9 returns the same thing for array.to_s as array.inspect, so just use array.inspect here
         @names.length == 1 ? "##{@names.first}" : @names.inspect
       end
     end