rspec 1.2.2 → 1.2.3

data/lib/spec/example/example_group_proxy.rb

@@ -1,7 +1,7 @@
 module Spec
   module Example
-    # Lightweight representation of an example group. This is the object
-    # that is passed to Spec::Runner::Formatter::BaseFormatter#add_example_group
+    # Lightweight proxy for an example group. This is the object that is passed
+    # to Spec::Runner::Formatter::BaseFormatter#example_group_started
     class ExampleGroupProxy
       
       def initialize(example_group) # :nodoc:
@@ -9,37 +9,38 @@ module Spec
         @nested_descriptions = example_group.nested_descriptions
         @examples            = example_group.example_proxies
         @location            = example_group.location
-        @backtrace           = example_group.backtrace
+        @backtrace           = example_group.location # deprecated - see the backtrace method below
       end
       
-      # This is the docstring passed to the <tt>describe()</tt> method or any
+      # This is the description passed to the <tt>describe()</tt> method or any
       # of its aliases
       attr_reader :description
       
       # Used by Spec::Runner::Formatter::NestedTextFormatter to access the
-      # docstrings for each example group in a nested group.
+      # description of each example group in a nested group separately.
       attr_reader :nested_descriptions
       
-      # A collection of ExampleGroupProxy instances, one for each example
+      # A collection of ExampleGroupProxy objects, one for each example
       # declared in this group.
       attr_reader :examples
       
-      # The file and line number at which the represented example group
+      # The file and line number at which the proxied example group
       # was declared. This is extracted from <tt>caller</tt>, and is therefore
       # formatted as an individual line in a backtrace.
       attr_reader :location
       
       # Deprecated - use location() instead
       def backtrace
+        Spec::deprecate("ExampleGroupProxy#backtrace","ExampleGroupProxy#location")
         @backtrace
       end
   
-      # Returns the nested_descriptions collection with any descriptions
-      # matching the submitted regexp removed.
+      # Deprecated - just use gsub on the description instead.
       def filtered_description(regexp)
-        build_description_from(
+        Spec::deprecate("ExampleGroupProxy#filtered_description","gsub (or similar) to modify ExampleGroupProxy#description")
+        ExampleGroupMethods.build_description_from(
           *nested_descriptions.collect do |description|
-            description =~ regexp ? $1 : description
+            description =~ regexp ? description.gsub($1, "") : description
           end
         )
       end
@@ -47,17 +48,6 @@ module Spec
       def ==(other) # :nodoc:
         other.description == description
       end
-      
-    private
-    
-      # FIXME - this is duplicated from ExampleGroupMethods
-      def build_description_from(*args)
-        text = args.inject("") do |description, arg|
-          description << " " unless (description == "" || arg.to_s =~ /^(\s|\.|#)/)
-          description << arg.to_s
-        end
-        text == "" ? nil : text
-      end
     end
   end
 end

data/lib/spec/example/example_methods.rb

@@ -18,7 +18,11 @@ module Spec
       #   description
       #   => "should start with a balance of 0"
       def description
-        @_proxy.description || ::Spec::Matchers.generated_description || "NO NAME"
+        if description = @_proxy.description || ::Spec::Matchers.generated_description
+          description
+        else
+          raise Spec::Example::NoDescriptionError.new("example", @_proxy.location)
+        end
       end
       
       def options # :nodoc:
@@ -81,20 +85,6 @@ module Spec
         end
       end
 
-      # Provides the backtrace up to where this example was declared.
-      def backtrace
-        @_backtrace
-      end
-      
-      # Deprecated - use +backtrace()+
-      def implementation_backtrace
-        Kernel.warn <<-WARNING
-ExampleMethods#implementation_backtrace is deprecated and will be removed
-from a future version. Please use ExampleMethods#backtrace instead.
-WARNING
-        backtrace
-      end
-      
       # Run all the before(:each) blocks for this example
       def run_before_each
         example_group_hierarchy.run_before_each(self)
@@ -116,19 +106,19 @@ WARNING
       include Matchers
       include Pending
       
-      def before_each_example # :nodoc:
+      def before_each_example
         setup_mocks_for_rspec
         run_before_each
       end
 
-      def after_each_example # :nodoc:
+      def after_each_example
         run_after_each
         verify_mocks_for_rspec
       ensure
         teardown_mocks_for_rspec
       end
 
-      def described_class # :nodoc:
+      def described_class
         self.class.described_class
       end
       

data/lib/spec/example/example_proxy.rb

@@ -1,8 +1,7 @@
 module Spec
   module Example
-    # Lightweight representation of an example. This is the object
-    # that is passed to example-related methods in
-    # Spec::Runner::Formatter::BaseFormatter
+    # Lightweight proxy for an example. This is the object that is passed to
+    # example-related methods in Spec::Runner::Formatter::BaseFormatter
     class ExampleProxy
 
       def initialize(description=nil, options={}, location=nil) # :nodoc:
@@ -24,6 +23,7 @@ module Spec
       
       # Deprecated - use location()
       def backtrace
+        Spec.deprecate("ExampleProxy#backtrace","ExampleProxy#location")
         location
       end
       
@@ -35,7 +35,7 @@ module Spec
       end
       
       def ==(other) # :nodoc:
-        (other.description == description) & (other.backtrace == backtrace)
+        (other.description == description) & (other.location == location)
       end
     end
   end

data/lib/spec/example/pending.rb

@@ -2,16 +2,15 @@ module Spec
   module Example      
     module Pending
       def pending(message = "TODO")
-        pending_caller = caller[0]
         if block_given?
           begin
             yield
-          rescue Exception => e
-            raise Spec::Example::ExamplePendingError.new(message, pending_caller)
+          rescue Exception
+            raise Spec::Example::ExamplePendingError.new(message)
           end
           raise Spec::Example::PendingExampleFixedError.new("Expected pending '#{message}' to fail. No Error was raised.")
         else
-          raise Spec::Example::ExamplePendingError.new(message, pending_caller)
+          raise Spec::Example::ExamplePendingError.new(message)
         end
       end
     end

data/lib/spec/example/predicate_matchers.rb

@@ -30,7 +30,7 @@ module Spec
       #     end
       #   end
       def predicate_matchers
-        @predicate_matchers ||= {}
+        @predicate_matchers ||= Spec::HashWithDeprecationNotice.new("predicate_matchers", "the new Matcher DSL")
       end
 
       def define_methods_from_predicate_matchers # :nodoc:

data/lib/spec/example/subject.rb

@@ -19,6 +19,8 @@ module Spec
             explicit_subject || implicit_subject : @_explicit_subject_block = block
         end
         
+      private
+      
         def explicit_subject
           if defined?(@_explicit_subject_block)
             @_explicit_subject_block

data/lib/spec/expectations.rb

@@ -1,4 +1,5 @@
 require 'spec/matchers'
+require 'spec/expectations/fail_with'
 require 'spec/expectations/errors'
 require 'spec/expectations/extensions'
 require 'spec/expectations/handler'
@@ -30,31 +31,5 @@ module Spec
   # RSpec ships with a standard set of useful matchers, and writing your own
   # matchers is quite simple. See Spec::Matchers for details.
   module Expectations
-    def self.differ
-      defined?(@differ) ? @differ : nil
-    end
-    
-    def self.differ=(differ)
-      @differ = differ
-    end
-
-    # raises a Spec::Expectations::ExpectationNotMetError with message
-    #
-    # When a differ has been assigned and fail_with is passed
-    # <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)
-        message, expected, target = message[0], message[1], message[2]
-      end
-      unless (differ.nil? || expected.nil? || target.nil?)
-        if expected.is_a?(String)
-          message << "\nDiff:" << self.differ.diff_as_string(target.to_s, expected)
-        elsif !target.is_a?(Proc)
-          message << "\nDiff:" << self.differ.diff_as_object(target, expected)
-        end
-      end
-      Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
-    end
   end
 end

data/lib/spec/expectations/extensions.rb

@@ -1 +1 @@
-require 'spec/expectations/extensions/object'
+require 'spec/expectations/extensions/kernel'

data/lib/spec/expectations/extensions/kernel.rb

@@ -0,0 +1,52 @@
+module Kernel
+  # :call-seq:
+  #   should(matcher)
+  #   should == expected
+  #   should === expected
+  #   should =~ expected
+  #
+  #   receiver.should(matcher)
+  #     => Passes if matcher.matches?(receiver)
+  #
+  #   receiver.should == expected #any value
+  #     => Passes if (receiver == expected)
+  #
+  #   receiver.should === expected #any value
+  #     => Passes if (receiver === expected)
+  #
+  #   receiver.should =~ regexp
+  #     => Passes if (receiver =~ regexp)
+  #
+  # See Spec::Matchers for more information about matchers
+  #
+  # == Warning
+  #
+  # NOTE that this does NOT support receiver.should != expected.
+  # Instead, use receiver.should_not == expected
+  def should(matcher=nil, &block)
+    Spec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, &block)
+  end
+
+  # :call-seq:
+  #   should_not(matcher)
+  #   should_not == expected
+  #   should_not === expected
+  #   should_not =~ expected
+  #
+  #   receiver.should_not(matcher)
+  #     => Passes unless matcher.matches?(receiver)
+  #
+  #   receiver.should_not == expected
+  #     => Passes unless (receiver == expected)
+  #
+  #   receiver.should_not === expected
+  #     => Passes unless (receiver === expected)
+  #
+  #   receiver.should_not =~ regexp
+  #     => Passes unless (receiver =~ regexp)
+  #
+  # See Spec::Matchers for more information about matchers
+  def should_not(matcher=nil, &block)
+    Spec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, &block)
+  end
+end

data/lib/spec/expectations/handler.rb

@@ -2,7 +2,7 @@ module Spec
   module Expectations
     class InvalidMatcherError < ArgumentError; end        
     
-    class ExpectationMatcherHandler        
+    class PositiveExpectationHandler        
       def self.handle_matcher(actual, matcher, &block)
         ::Spec::Matchers.last_should = :should
         ::Spec::Matchers.last_matcher = matcher
@@ -10,28 +10,39 @@ module Spec
 
         match = matcher.matches?(actual, &block)
         return match if match
-
-        ::Spec::Expectations.fail_with matcher.respond_to?(:failure_message_for_should) ?
-                                       matcher.failure_message_for_should :
-                                       matcher.failure_message
+        
+        message = matcher.respond_to?(:failure_message_for_should) ?
+                  matcher.failure_message_for_should :
+                  matcher.failure_message
+        
+        if matcher.respond_to?(:diffable?) && matcher.diffable?
+          ::Spec::Expectations.fail_with message, matcher.expected.first, matcher.actual
+        else
+          ::Spec::Expectations.fail_with message
+        end
       end
     end
 
-    class NegativeExpectationMatcherHandler
+    class NegativeExpectationHandler
       def self.handle_matcher(actual, matcher, &block)
         ::Spec::Matchers.last_should = :should_not
         ::Spec::Matchers.last_matcher = matcher
-
         return ::Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
         
         match = matcher.respond_to?(:does_not_match?) ?
                 !matcher.does_not_match?(actual, &block) :
                 matcher.matches?(actual, &block)
         return match unless match
+        
+        message = matcher.respond_to?(:failure_message_for_should_not) ?
+                  matcher.failure_message_for_should_not :
+                  matcher.negative_failure_message
 
-        ::Spec::Expectations.fail_with matcher.respond_to?(:failure_message_for_should_not) ?
-                                       matcher.failure_message_for_should_not :
-                                       matcher.negative_failure_message
+        if matcher.respond_to?(:diffable?) && matcher.diffable?
+          ::Spec::Expectations.fail_with message, matcher.expected.first, matcher.actual
+        else
+          ::Spec::Expectations.fail_with message
+        end
       end
     end
   end

data/lib/spec/matchers/be.rb

@@ -41,12 +41,12 @@ module Spec
         else
           message = <<-MESSAGE
 'should_not be #{@comparison_method} #{expected}' not only FAILED,
-it reads really poorly.
+it is a bit confusing.
           MESSAGE
           
           raise message << ([:===,:==].include?(@comparison_method) ?
-            "Why don't you try expressing it without the \"be\"?" :
-            "Why don't you try expressing it in the positive?")
+            "It might be more clearly expressed without the \"be\"?" :
+            "It might be more clearly expressed in the positive?")
         end
       end
       

data/lib/spec/matchers/be_close.rb

@@ -1,25 +1,5 @@
 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_for_should
-        "expected #{@expected} +/- (< #{@delta}), got #{@actual}"
-      end
-      
-      def description
-        "be close to #{@expected} (within +- #{@delta})"
-      end
-    end
-
     # :call-seq:
     #   should be_close(expected, delta)
     #   should_not be_close(expected, delta)
@@ -30,7 +10,23 @@ module Spec
     #
     #   result.should be_close(3.0, 0.5)
     def be_close(expected, delta)
-      BeClose.new(expected, delta)
+      Matcher.new :be_close, expected, delta do |expected, delta|
+        match do |actual|
+          (actual - expected).abs < delta
+        end
+
+        failure_message_for_should do |actual|
+          "expected #{expected} +/- (< #{delta}), got #{actual}"
+        end
+
+        failure_message_for_should_not do |actual|
+          "expected #{expected} +/- (< #{delta}), got #{actual}"
+        end
+
+        description do
+          "be close to #{expected} (within +- #{delta})"
+        end
+      end
     end
   end
 end

data/lib/spec/matchers/be_instance_of.rb

@@ -1,28 +1,5 @@
 module Spec
   module Matchers
-    class BeInstanceOf
-      def initialize(expected)
-        @expected = expected
-      end
-      
-      def matches?(actual)
-        @actual = actual
-        @actual.instance_of?(@expected)
-      end
-      
-      def description
-        "be an instance of #{@expected}"
-      end
-      
-      def failure_message_for_should
-        "expected instance of #{@expected}, got #{@actual.inspect}"
-      end
-      
-      def failure_message_for_should_not
-        "expected #{@actual.inspect} not to be an instance of #{@expected}"
-      end
-    end
-
     # :call-seq:
     #   should be_instance_of(expected)
     #   should be_an_instance_of(expected)
@@ -36,10 +13,14 @@ module Spec
     #   5.should be_instance_of(Fixnum)
     #   5.should_not be_instance_of(Numeric)
     #   5.should_not be_instance_of(Float)
-    def be_instance_of(expected)
-      BeInstanceOf.new(expected)
+    def be_an_instance_of(expected)
+      Matcher.new :be_an_instance_of, expected do |expected|
+        match do |actual|
+          actual.instance_of?(expected)
+        end
+      end
     end
     
-    alias_method :be_an_instance_of, :be_instance_of
+    alias_method :be_instance_of, :be_an_instance_of
   end
 end