rspec 1.1.12 → 1.2.0

data/lib/spec/example/example_methods.rb

@@ -2,54 +2,41 @@ module Spec
   module Example
     module ExampleMethods
       
-      extend ModuleReopeningFix
-      
-      def subject # :nodoc: this is somewhat experimental
-        @subject ||= ( instance_variable_get(subject_variable_name) ||
-                       instance_eval(&self.class.subject_block) ||
-                       (described_class ? described_class.new : nil) )
-      end
-
-      # When +should+ is called with no explicit receiver, the call is
-      # delegated to the *subject* of the example group. This could be either
-      # an explicit subject generated by calling the block passed to
-      # +ExampleGroupMethods#subject+, or, if the group is describing a class,
-      # an implicitly generated instance of that class.
-      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.
-      def should_not(matcher)
-        subject.should_not(matcher)
-      end
+      extend  Spec::Example::ModuleReopeningFix
+      include Spec::Example::Subject::ExampleMethods
       
       def violated(message="")
         raise Spec::Expectations::ExpectationNotMetError.new(message)
       end
 
+      # Declared description for this example:
+      #
+      #   describe Account do
+      #     it "should start with a balance of 0" do
+      #     ...
+      #
+      #   description
+      #   => "should start with a balance of 0"
       def description
         @_defined_description || ::Spec::Matchers.generated_description || "NO NAME"
       end
       
-      def options
+      def options # :nodoc:
         @_options
       end
 
-      def execute(options, instance_variables)
-        options.reporter.example_started(self)
+      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("")
         set_instance_variables_from_hash(instance_variables)
         
         execution_error = nil
-        Timeout.timeout(options.timeout) do
+        Timeout.timeout(run_options.timeout) do
           begin
             before_each_example
-            eval_block
+            instance_eval(&@_implementation)
           rescue Exception => e
             execution_error ||= e
           end
@@ -60,28 +47,19 @@ module Spec
           end
         end
 
-        options.reporter.example_finished(self, execution_error)
+        run_options.reporter.example_finished(ExampleDescription.new(description, options), execution_error)
         success = execution_error.nil? || ExamplePendingError === execution_error
       end
 
-      def instance_variable_hash # :nodoc:
-        instance_variables.inject({}) do |variable_hash, variable_name|
-          variable_hash[variable_name] = instance_variable_get(variable_name)
-          variable_hash
-        end
+      def eval_each_fail_fast(blocks) # :nodoc:
+        blocks.each {|block| instance_eval(&block)}
       end
 
-      def eval_each_fail_fast(examples) # :nodoc:
-        examples.each do |example|
-          instance_eval(&example)
-        end
-      end
-
-      def eval_each_fail_slow(examples) # :nodoc:
+      def eval_each_fail_slow(blocks) # :nodoc:
         first_exception = nil
-        examples.each do |example|
+        blocks.each do |block|
           begin
-            instance_eval(&example)
+            instance_eval(&block)
           rescue Exception => e
             first_exception ||= e
           end
@@ -89,31 +67,22 @@ module Spec
         raise first_exception if first_exception
       end
 
-      # Concats the class description with the example description.
-      #
-      #   describe Account do
-      #     it "should start with a balance of 0" do
-      #     ...
-      #
-      #   full_description
-      #   => "Account should start with a balance of 0"
-      def full_description
-        "#{self.class.description} #{self.description}"
+      def instance_variable_hash # :nodoc:
+        instance_variables.inject({}) do |variable_hash, variable_name|
+          variable_hash[variable_name] = instance_variable_get(variable_name)
+          variable_hash
+        end
       end
-      
+
       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 ['@_implementation', '@_defined_description', '@_matcher_description', '@method_name'].include?(variable_name.to_s)
+          unless ['@_defined_description', '@_options', '@_implementation', '@method_name'].include?(variable_name.to_s)
             instance_variable_set variable_name, value
           end
         end
       end
 
-      def eval_block # :nodoc:
-        instance_eval(&@_implementation)
-      end
-
       # Provides the backtrace up to where this example was declared.
       def backtrace
         @_backtrace
@@ -127,42 +96,53 @@ 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)
+      end
+
+      # Run all the after(:each) blocks for this example
+      def run_after_each
+        example_group_hierarchy.run_after_each(self)
+      end
 
-      private
+      def initialize(description, options={}, &implementation)
+        @_options = options
+        @_defined_description = description
+        @_implementation = implementation
+        @_backtrace = caller
+      end
+
+    private
+    
       include Matchers
       include Pending
       
-      def before_each_example
+      def before_each_example # :nodoc:
         setup_mocks_for_rspec
-        self.class.run_before_each(self)
+        run_before_each
       end
 
-      def after_each_example
-        self.class.run_after_each(self)
+      def after_each_example # :nodoc:
+        run_after_each
         verify_mocks_for_rspec
       ensure
         teardown_mocks_for_rspec
       end
 
-      def subject_variable_name
-        '@' << (described_class ? underscore(described_class.name) : '__this_does_not_exist')
+      def described_class # :nodoc:
+        self.class.described_class
       end
       
-      def described_class
-        Class === described_type ? described_type : nil
-      end
-      
-      def described_type
-        self.class.described_type
+      def description_args
+        self.class.description_args
       end
 
-      def underscore(camel_cased_word)
-        camel_cased_word.to_s.gsub(/::/, '_').
-          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-          gsub(/([a-z\d])([A-Z])/,'\1_\2').
-          tr("-", "_").
-          downcase
+      def example_group_hierarchy
+        self.class.example_group_hierarchy
       end
+      
     end
   end
 end

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/pending.rb

@@ -2,15 +2,16 @@ 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)
+            raise Spec::Example::ExamplePendingError.new(message, pending_caller)
           end
           raise Spec::Example::PendingExampleFixedError.new("Expected pending '#{message}' to fail. No Error was raised.")
         else
-          raise Spec::Example::ExamplePendingError.new(message)
+          raise Spec::Example::ExamplePendingError.new(message, pending_caller)
         end
       end
     end

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 {description_args.first})
+          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/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/expectations/differs/default.rb

@@ -1,5 +1,4 @@
 begin
-  require 'rubygems'
   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

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

@@ -6,12 +6,14 @@ module Spec
       def self.handle_matcher(actual, matcher, &block)
         ::Spec::Matchers.last_should = :should
         ::Spec::Matchers.last_matcher = matcher
-
         return ::Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
 
         match = matcher.matches?(actual, &block)
-        ::Spec::Expectations.fail_with(matcher.failure_message) unless match
-        match
+        return match if match
+
+        ::Spec::Expectations.fail_with matcher.respond_to?(:failure_message_for_should) ?
+                                       matcher.failure_message_for_should :
+                                       matcher.failure_message
       end
     end
 
@@ -22,9 +24,14 @@ module Spec
 
         return ::Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
         
-        match = matcher.matches?(actual, &block)
-        ::Spec::Expectations.fail_with(matcher.negative_failure_message) if match
-        match
+        match = matcher.respond_to?(:does_not_match?) ?
+                !matcher.does_not_match?(actual, &block) :
+                matcher.matches?(actual, &block)
+        return match unless match
+
+        ::Spec::Expectations.fail_with matcher.respond_to?(:failure_message_for_should_not) ?
+                                       matcher.failure_message_for_should_not :
+                                       matcher.negative_failure_message
       end
     end
   end