rspec 1.2.0 → 1.2.1

data/lib/spec/example/example_methods.rb

@@ -18,18 +18,16 @@ module Spec
       #   description
       #   => "should start with a balance of 0"
       def description
-        @_defined_description || ::Spec::Matchers.generated_description || "NO NAME"
+        @_proxy.description || ::Spec::Matchers.generated_description || "NO NAME"
       end
       
       def options # :nodoc:
-        @_options
+        @_proxy.options
       end
 
       def execute(run_options, instance_variables) # :nodoc:
-        # FIXME - there is no reason to have example_started pass a name
-        # - in fact, it would introduce bugs in cases where no docstring
-        # is passed to it()
-        run_options.reporter.example_started("")
+        puts caller unless caller(0)[1] =~ /example_group_methods/
+        run_options.reporter.example_started(@_proxy)
         set_instance_variables_from_hash(instance_variables)
         
         execution_error = nil
@@ -47,7 +45,7 @@ module Spec
           end
         end
 
-        run_options.reporter.example_finished(ExampleDescription.new(description, options), execution_error)
+        run_options.reporter.example_finished(@_proxy.update(description), execution_error)
         success = execution_error.nil? || ExamplePendingError === execution_error
       end
 
@@ -77,7 +75,7 @@ module Spec
       def set_instance_variables_from_hash(ivars) # :nodoc:
         ivars.each do |variable_name, value|
           # Ruby 1.9 requires variable.to_s on the next line
-          unless ['@_defined_description', '@_options', '@_implementation', '@method_name'].include?(variable_name.to_s)
+          unless ['@_proxy', '@_implementation', '@method_name'].include?(variable_name.to_s)
             instance_variable_set variable_name, value
           end
         end
@@ -107,9 +105,8 @@ WARNING
         example_group_hierarchy.run_after_each(self)
       end
 
-      def initialize(description, options={}, &implementation)
-        @_options = options
-        @_defined_description = description
+      def initialize(example_proxy, &implementation)
+        @_proxy = example_proxy
         @_implementation = implementation
         @_backtrace = caller
       end

data/lib/spec/example/example_proxy.rb

@@ -0,0 +1,42 @@
+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
+    class ExampleProxy
+
+      def initialize(description=nil, options={}, location=nil) # :nodoc:
+        @description, @options, @location = description, options, location
+      end
+      
+      # 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.
+      attr_reader :location
+      
+      # Deprecated - use location()
+      def backtrace
+        location
+      end
+      
+      # Convenience method for example group - updates the value of
+      # <tt>description</tt> and returns self.
+      def update(description) # :nodoc:
+        @description = description
+        self
+      end
+      
+      def ==(other) # :nodoc:
+        (other.description == description) & (other.backtrace == backtrace)
+      end
+    end
+  end
+end

data/lib/spec/example/shared_example_group.rb

@@ -39,7 +39,7 @@ module Spec
         end
 
         def expanded_path(example_group)
-          File.expand_path(example_group.spec_path)
+          File.expand_path(example_group.location)
         end
       end
 

data/lib/spec/example/subject.rb

@@ -15,12 +15,23 @@ module Spec
         #
         # See +ExampleMethods#should+ for more information about this approach.
         def subject(&block)
-          if block.nil?
-            @_subject_block || (described_class ? lambda {described_class.new} : lambda {description_args.first})
+          block.nil? ?
+            explicit_subject || implicit_subject : @_explicit_subject_block = block
+        end
+        
+        def explicit_subject
+          if defined?(@_explicit_subject_block)
+            @_explicit_subject_block
+          elsif super_subject = superclass.instance_variable_get('@_explicit_subject_block')
+            super_subject
           else
-            @_subject_block = block
+            nil
           end
         end
+        
+        def implicit_subject
+          (described_class ? lambda {described_class.new} : lambda {description_args.first})
+        end
       end
       
       module ExampleMethods

data/lib/spec/expectations.rb

@@ -31,7 +31,7 @@ module Spec
   # matchers is quite simple. See Spec::Matchers for details.
   module Expectations
     def self.differ
-      @differ
+      defined?(@differ) ? @differ : nil
     end
     
     def self.differ=(differ)

data/lib/spec/expectations/differs/default.rb

@@ -1,64 +1,61 @@
-begin
-  require 'diff/lcs' #necessary due to loading bug on some machines - not sure why - DaC
-  require 'diff/lcs/hunk'
-rescue LoadError ; raise "You must gem install diff-lcs to use diffing" ; end
-
+require File.join(File.dirname(__FILE__), "/load-diff-lcs")
 require 'pp'
 
 module Spec
   module Expectations
     module Differs
+      unless defined?(Default)
+        class Default
+          def initialize(options)
+            @options = options
+          end
 
-      # TODO add some rdoc
-      class Default
-        def initialize(options)
-          @options = options
-        end
-
-        # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-        def diff_as_string(data_new, data_old)
-          data_old = data_old.split(/\n/).map! { |e| e.chomp }
-          data_new = data_new.split(/\n/).map! { |e| e.chomp }
-          output = ""
-          diffs = Diff::LCS.diff(data_old, data_new)
-          return output if diffs.empty?
-          oldhunk = hunk = nil  
-          file_length_difference = 0
-          diffs.each do |piece|
-            begin
-              hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
-                                         file_length_difference)
-              file_length_difference = hunk.file_length_difference      
-              next unless oldhunk      
-              # Hunks may overlap, which is why we need to be careful when our
-              # diff includes lines of context. Otherwise, we might print
-              # redundant lines.
-              if (context_lines > 0) and hunk.overlaps?(oldhunk)
-                hunk.unshift(oldhunk)
-              else
-                output << oldhunk.diff(format)
+          # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+          def diff_as_string(data_new, data_old)
+            data_old = data_old.split(/\n/).map! { |e| e.chomp }
+            data_new = data_new.split(/\n/).map! { |e| e.chomp }
+            output = ""
+            diffs = Diff::LCS.diff(data_old, data_new)
+            return output if diffs.empty?
+            oldhunk = hunk = nil  
+            file_length_difference = 0
+            diffs.each do |piece|
+              begin
+                hunk = Diff::LCS::Hunk.new(data_old, data_new, piece, context_lines,
+                                           file_length_difference)
+                file_length_difference = hunk.file_length_difference      
+                next unless oldhunk      
+                # Hunks may overlap, which is why we need to be careful when our
+                # diff includes lines of context. Otherwise, we might print
+                # redundant lines.
+                if (context_lines > 0) and hunk.overlaps?(oldhunk)
+                  hunk.unshift(oldhunk)
+                else
+                  output << oldhunk.diff(format)
+                end
+              ensure
+                oldhunk = hunk
+                output << "\n"
               end
-            ensure
-              oldhunk = hunk
-              output << "\n"
-            end
+            end  
+            #Handle the last remaining hunk
+            output << oldhunk.diff(format) << "\n"
           end  
-          #Handle the last remaining hunk
-          output << oldhunk.diff(format) << "\n"
-        end  
 
-        def diff_as_object(target,expected)
-          diff_as_string(PP.pp(target,""), PP.pp(expected,""))
-        end
+          def diff_as_object(target,expected)
+            diff_as_string(PP.pp(target,""), PP.pp(expected,""))
+          end
 
-        protected
-        def format
-          @options.diff_format
-        end
+          protected
+          def format
+            @options.diff_format
+          end
 
-        def context_lines
-          @options.context_lines
+          def context_lines
+            @options.context_lines
+          end
         end
+
       end
     end
   end

data/lib/spec/expectations/differs/load-diff-lcs.rb

@@ -0,0 +1,12 @@
+begin
+  require 'diff/lcs'
+rescue LoadError
+  begin
+    require 'rubygems' unless ENV['NO_RUBYGEMS']
+    require 'diff/lcs'
+  rescue LoadError
+    raise "You must gem install diff-lcs to use diffing"
+  end
+end
+
+require 'diff/lcs/hunk'

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

@@ -40,10 +40,10 @@ module Test
       before(:each) {setup}
       after(:each) {teardown}
 
-      def initialize(description, options={}, &implementation)
+      def initialize(description, &implementation)
         super
         # Some Test::Unit extensions depend on @method_name being present.
-        @method_name = description
+        @method_name = description.description
         @_result = ::Test::Unit::TestResult.new
       end
 

data/lib/spec/matchers.rb

@@ -1,4 +1,5 @@
 require 'spec/matchers/extensions/instance_exec'
+require 'spec/matchers/pretty'
 require 'spec/matchers/matcher'
 require 'spec/matchers/operator_matcher'
 require 'spec/matchers/be'
@@ -24,6 +25,7 @@ require 'spec/matchers/simple_matcher'
 require 'spec/matchers/throw_symbol'
 require 'spec/matchers/wrap_expectation'
 require 'spec/matchers/compatibility'
+require 'spec/matchers/dsl'
 
 module Spec
 
@@ -82,14 +84,17 @@ module Spec
   # You can use this feature to invoke any predicate that begins with "has_", whether it is
   # part of the Ruby libraries (like +Hash#has_key?+) or a method you wrote on your own class.
   #
-  # == Custom Expectation Matchers
+  # == Custom Matchers
   #
   # When you find that none of the stock Expectation Matchers provide a natural
-  # feeling expectation, you can very easily write your own.
+  # feeling expectation, you can very easily write your own using RSpec's matcher
+  # DSL or writing one from scratch.
   #
-  # For example, imagine that you are writing a game in which players can
-  # be in various zones on a virtual board. To specify that bob should
-  # be in zone 4, you could say:
+  # === Matcher DSL
+  #
+  # Imagine that you are writing a game in which players can be in various
+  # zones on a virtual board. To specify that bob should be in zone 4, you
+  # could say:
   #
   #   bob.current_zone.should eql(Zone.new("4"))
   #
@@ -101,7 +106,42 @@ module Spec
   #
   #   bob.should_not be_in_zone("3")
   #
-  # To do this, you would need to write a class like this:
+  # You can create such a matcher like so:
+  #
+  #   Spec::Matchers.create :be_in_zone do |zone|
+  #     match do |player|
+  #       player.in_zone?(zone)
+  #     end
+  #   end
+  #
+  # This will generate a <tt>be_in_zone</tt> method that returns a matcher
+  # with logical default messages for failures. You can override the failure
+  # messages and the generated description as follows:
+  #
+  #   Spec::Matchers.create :be_in_zone do |zone|
+  #     match do |player|
+  #       player.in_zone?(zone)
+  #     end
+  #     failure_message_for_should do |player|
+  #       # generate and return the appropriate string.
+  #     end
+  #     failure_message_for_should_not do |player|
+  #       # generate and return the appropriate string.
+  #     end
+  #     description do
+  #       # generate and return the appropriate string.
+  #     end
+  #   end
+  #
+  # Each of the message-generation methods has access to the block arguments
+  # passed to the <tt>create</tt> method (in this case, <tt>zone</tt>). The
+  # failure message methods (<tt>failure_message_for_should</tt> and
+  # <tt>failure_message_for_should_not</tt>) are passed the actual value (the
+  # receiver of <tt>should</tt> or <tt>should_not</tt>).
+  #
+  # === Custom Matcher from scratch
+  #
+  # You could also write a custom matcher from scratch, as follows:
   #
   #   class BeInZone
   #     def initialize(expected)
@@ -111,10 +151,10 @@ module Spec
   #       @target = target
   #       @target.current_zone.eql?(Zone.new(@expected))
   #     end
-  #     def failure_message
+  #     def failure_message_for_should
   #       "expected #{@target.inspect} to be in Zone #{@expected}"
   #     end
-  #     def negative_failure_message
+  #     def failure_message_for_should_not
   #       "expected #{@target.inspect} not to be in Zone #{@expected}"
   #     end
   #   end
@@ -152,4 +192,4 @@ module Spec
   #   end
   #
   module Matchers; end
-end
+end

data/lib/spec/matchers/be.rb

@@ -2,9 +2,12 @@ module Spec
   module Matchers
     
     class Be #:nodoc:
+      include Spec::Matchers::Pretty
+      
       def initialize(*args)
         @expected = args.empty? ? true : set_expected(args.shift)
         @args = args
+        @comparison_method = nil
       end
       
       def matches?(actual)
@@ -98,6 +101,9 @@ it reads really poorly.
         end
         
         def prefix
+          # FIXME - this is a bit goofy - but we get failures
+          # if just defining @prefix = nil in initialize
+          @prefix = nil unless defined?(@prefix)
           @prefix
         end
 
@@ -107,7 +113,9 @@ it reads really poorly.
         
         def handling_predicate?
           return false if [true, false, nil].include?(expected)
-          return @handling_predicate
+          # FIXME - this is a bit goofy - but we get failures
+          # if just defining @handling_predicate = nil or false in initialize
+          return defined?(@handling_predicate) ? @handling_predicate : nil
         end
 
         def predicate
@@ -142,19 +150,8 @@ it reads really poorly.
           split_words(prefix)
         end
 
-        def split_words(sym)
-          sym.to_s.gsub(/_/,' ')
-        end
-
         def args_to_sentence
-          case @args.length
-            when 0
-              ""
-            when 1
-              " #{@args[0]}"
-            else
-              " #{@args[0...-1].join(', ')} and #{@args[-1]}"
-          end
+          to_sentence(@args)
         end
         
     end
@@ -163,9 +160,9 @@ it reads really poorly.
     #   should be_true
     #   should be_false
     #   should be_nil
-    #   should be_arbitrary_predicate(*args)
+    #   should be_[arbitrary_predicate](*args)
     #   should_not be_nil
-    #   should_not be_arbitrary_predicate(*args)
+    #   should_not be_[arbitrary_predicate](*args)
     #
     # Given true, false, or nil, will pass if actual value is
     # true, false or nil (respectively). Given no args means

data/lib/spec/matchers/change.rb

@@ -6,6 +6,7 @@ module Spec
       def initialize(receiver=nil, message=nil, &block)
         @message = message || "result"
         @value_proc = block || lambda {receiver.__send__(message)}
+        @to = @from = @minimum = @maximum = @amount = nil
       end
       
       def matches?(event_proc)