dchelimsky-rspec 1.1.11 → 1.1.11.1

data/lib/spec/example/example_group_methods.rb

@@ -3,28 +3,46 @@ module Spec
 
     module ExampleGroupMethods
       include Spec::Example::BeforeAndAfterHooks
+      
+      def self.matcher_class
+        @matcher_class
+      end
+      
+      def self.matcher_class=(matcher_class)
+        @matcher_class = matcher_class
+      end
 
-      class << self
-        attr_accessor :matcher_class
-
-        def description_text(*args)
-          args.inject("") do |result, arg|
-            result << " " unless (result == "" || arg.to_s =~ /^(\s|\.|#)/)
-            result << arg.to_s
-          end
+      def self.description_text(*args)
+        args.inject("") do |result, arg|
+          result << " " unless (result == "" || arg.to_s =~ /^(\s|\.|#)/)
+          result << arg.to_s
         end
       end
 
       attr_reader :description_text, :description_options, :spec_path
       alias :options :description_options
       
+      # Provides the backtrace up to where this example_group was declared.
+      def backtrace
+        @backtrace
+      end
+
+      # Deprecated - use +backtrace()+
+      def example_group_backtrace
+        Kernel.warn <<-WARNING
+ExampleGroupMethods#example_group_backtrace is deprecated and will be removed
+from a future version. Please use ExampleGroupMethods#backtrace instead.
+WARNING
+        backtrace
+      end
+      
       def description_args
         @description_args ||= []
       end
 
       def inherited(klass)
         super
-        klass.register {}
+        klass.register
         Spec::Runner.register_at_exit_hook
       end
       
@@ -46,11 +64,12 @@ module Spec
         args << {} unless Hash === args.last
         if example_group_block
           options = args.last
-          options[:spec_path] = eval("caller(0)[1]", example_group_block) unless options[:spec_path]
+          # Ruby 1.9 - the next line uses example_group_block.binding instead of example_group_block
+          options[:spec_path] = eval("caller(0)[1]", example_group_block.binding) unless options[:spec_path]
           if options[:shared]
             create_shared_example_group(*args, &example_group_block)
           else
-            create_nested_example_group(*args, &example_group_block)
+            create_subclass(*args, &example_group_block)
           end
         else
           set_description(*args)
@@ -58,11 +77,11 @@ module Spec
       end
       alias :context :describe
       
-      def create_shared_example_group(*args, &example_group_block)
+      def create_shared_example_group(*args, &example_group_block) # :nodoc:
         SharedExampleGroup.register(*args, &example_group_block)
       end
       
-      def create_nested_example_group(*args, &example_group_block)
+      def create_subclass(*args, &example_group_block) # :nodoc:
         self.subclass("Subclass") do
           set_description(*args)
           module_eval(&example_group_block)
@@ -164,13 +183,13 @@ module Spec
       #
       # See +ExampleMethods#should+ for more information about this approach.
       def subject(&block)
-        if block
-          @_subject_block = block
-        else
-          @_subject_block.call if @_subject_block
-        end
+        @_subject_block = block
       end
-
+      
+      def subject_block
+        @_subject_block || lambda {nil}
+      end
+      
       def description_parts #:nodoc:
         parts = []
         each_ancestor_example_group_class do |example_group_class|
@@ -184,6 +203,7 @@ module Spec
         @description_args = args
         @description_options = options
         @description_text = ExampleGroupMethods.description_text(*args)
+        @backtrace = caller(1)
         @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path]
         self
       end
@@ -206,8 +226,7 @@ module Spec
         @after_each_parts = nil
       end
 
-      def register(&registration_binding_block)
-        @registration_binding_block = registration_binding_block
+      def register
         Spec::Runner.options.add_example_group self
       end
 
@@ -215,10 +234,6 @@ module Spec
         Spec::Runner.options.remove_example_group self
       end
 
-      def registration_backtrace
-        eval("caller", @registration_binding_block)
-      end
-
       def run_before_each(example)
         each_ancestor_example_group_class do |example_group_class|
           example.eval_each_fail_fast(example_group_class.before_each_parts)

data/lib/spec/example/example_methods.rb

@@ -4,9 +4,10 @@ module Spec
       
       extend ModuleReopeningFix
       
-      def subject # :nodoc:
-        @subject ||= (instance_variable_get(subject_variable_name) || self.class.subject ||
-          (described_class ? described_class.new : nil))
+      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
@@ -63,20 +64,20 @@ module Spec
         success = execution_error.nil? || ExamplePendingError === execution_error
       end
 
-      def instance_variable_hash
+      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 eval_each_fail_fast(examples) #:nodoc:
+      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(examples) # :nodoc:
         first_exception = nil
         examples.each do |example|
           begin
@@ -109,12 +110,22 @@ module Spec
         end
       end
 
-      def eval_block
+      def eval_block # :nodoc:
         instance_eval(&@_implementation)
       end
 
+      # Provides the backtrace up to where this example was declared.
+      def backtrace
+        @_backtrace
+      end
+      
+      # Deprecated - use +backtrace()+
       def implementation_backtrace
-        eval("caller", @_implementation)
+        Kernel.warn <<-WARNING
+ExampleMethods#implementation_backtrace is deprecated and will be removed
+from a future version. Please use ExampleMethods#backtrace instead.
+WARNING
+        backtrace
       end
 
       private

data/lib/spec/example.rb

@@ -1,26 +1,24 @@
 module Spec
   module Example
-    class << self
-      def args_and_options(*args)
-        with_options_from(args) do |options|
-          return args, options
-        end
+    def self.args_and_options(*args)
+      with_options_from(args) do |options|
+        return args, options
       end
+    end
 
-      def scope_from(*args)
-        args[0] || :each
-      end
+    def self.scope_from(*args)
+      args[0] || :each
+    end
 
-      def scope_and_options(*args)
-        args, options = args_and_options(*args)
-        return scope_from(*args), options
-      end
+    def self.scope_and_options(*args)
+      args, options = args_and_options(*args)
+      return scope_from(*args), options
+    end
 
-    private
-      
-      def with_options_from(args)
-        yield Hash === args.last ? args.pop : {} if block_given?
-      end
+  private
+    
+    def self.with_options_from(args)
+      yield Hash === args.last ? args.pop : {} if block_given?
     end
   end
 end

data/lib/spec/expectations/handler.rb

@@ -3,50 +3,45 @@ module Spec
     class InvalidMatcherError < ArgumentError; end        
     
     class ExpectationMatcherHandler        
-      class << self
-        def handle_matcher(actual, matcher, &block)
-          ::Spec::Matchers.last_should = "should"
-          return Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
+      def self.handle_matcher(actual, matcher, &block)
+        ::Spec::Matchers.last_should = "should"
+        return Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
 
-          unless matcher.respond_to?(:matches?)
-            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
-          end
-          
-          match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.last_matcher = matcher
-          Spec::Expectations.fail_with(matcher.failure_message) unless match
-          match
+        unless matcher.respond_to?(:matches?)
+          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
         end
+        
+        match = matcher.matches?(actual, &block)
+        ::Spec::Matchers.last_matcher = matcher
+        Spec::Expectations.fail_with(matcher.failure_message) unless match
+        match
       end
     end
 
     class NegativeExpectationMatcherHandler
-      class << self
-        def handle_matcher(actual, matcher, &block)
-          ::Spec::Matchers.last_should = "should not"
-          return Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
-          
-          unless matcher.respond_to?(:matches?)
-            raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
-          end
+      def self.handle_matcher(actual, matcher, &block)
+        ::Spec::Matchers.last_should = "should not"
+        return Spec::Matchers::NegativeOperatorMatcher.new(actual) if matcher.nil?
+        
+        unless matcher.respond_to?(:matches?)
+          raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
+        end
 
-          unless matcher.respond_to?(:negative_failure_message)
-            Spec::Expectations.fail_with(
+        unless matcher.respond_to?(:negative_failure_message)
+          Spec::Expectations.fail_with(
 <<-EOF
 Matcher does not support should_not.
 See Spec::Matchers for more information
 about matchers.
 EOF
 )
-          end
-          match = matcher.matches?(actual, &block)
-          ::Spec::Matchers.last_matcher = matcher
-          Spec::Expectations.fail_with(matcher.negative_failure_message) if match
-          match
         end
+        match = matcher.matches?(actual, &block)
+        ::Spec::Matchers.last_matcher = matcher
+        Spec::Expectations.fail_with(matcher.negative_failure_message) if match
+        match
       end
     end
-
   end
 end
 

data/lib/spec/expectations/wrap_expectation.rb

@@ -0,0 +1,56 @@
+module Spec
+  module Matchers
+    
+    # wraps an expectation in a block that will return true if the
+    # expectation passes and false if it fails (without bubbling up
+    # the failure).
+    #     
+    # This is intended to be used in the context of a simple matcher,
+    # and is especially useful for wrapping multiple expectations or
+    # one or more assertions from test/unit extensions when running
+    # with test/unit.
+    #
+    # == Examples
+    #
+    #   def eat_cheese(cheese)
+    #     simple_matcher do |mouse, matcher|
+    #       matcher.negative_failure_message = "expected #{mouse} not to eat cheese"
+    #       wrap_expectation do |matcher|
+    #         assert_eats_cheese(mouse)
+    #       end
+    #     end
+    #   end
+    #
+    #   describe Mouse do
+    #     it "eats cheese" do
+    #       Mouse.new.should eat_cheese
+    #     end
+    #   end
+    #
+    # You might be wondering "why would I do this if I could just say"
+    # assert_eats_cheese?", a fair question, indeed. You might prefer
+    # to replace the word assert with something more aligned with the
+    # rest of your code examples. You are using rspec, after all.
+    #
+    # The other benefit you get is that you can use the negative version
+    # of the matcher:
+    #
+    #   describe Cat do
+    #     it "does not eat cheese" do
+    #       Cat.new.should_not eat_cheese
+    #     end
+    #   end
+    #
+    # So in the event there is no assert_does_not_eat_cheese available,
+    # you're all set!
+    def wrap_expectation(matcher, &block)
+      begin
+        block.call(matcher)
+        return true
+      rescue Exception => e
+        matcher.failure_message = e.message
+        return false
+      end
+    end
+  end
+end

data/lib/spec/expectations.rb

@@ -31,27 +31,31 @@ 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
-    class << self
-      attr_accessor :differ
+    def self.differ
+      @differ
+    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 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
+    # 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
-        Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
       end
+      Kernel::raise(Spec::Expectations::ExpectationNotMetError.new(message))
     end
   end
 end

data/lib/spec/extensions.rb

@@ -1,2 +1 @@
 require 'spec/extensions/class'
-require 'spec/extensions/metaclass'

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

@@ -23,26 +23,24 @@ module Test
       extend Spec::Example::ExampleGroupMethods
       include Spec::Example::ExampleMethods
 
-      before(:each) {setup}
-      after(:each) {teardown}
-
-      class << self
-        def suite
-          Test::Unit::TestSuiteAdapter.new(self)
-        end
+      def self.suite
+        Test::Unit::TestSuiteAdapter.new(self)
+      end
 
-        def example_method?(method_name)
-          should_method?(method_name) || test_method?(method_name)
-        end
+      def self.example_method?(method_name)
+        should_method?(method_name) || test_method?(method_name)
+      end
 
-        def test_method?(method_name)
-          method_name =~ /^test[_A-Z]./ && (
-            instance_method(method_name).arity == 0 ||
-            instance_method(method_name).arity == -1
-          )
-        end
+      def self.test_method?(method_name)
+        method_name =~ /^test[_A-Z]./ && (
+          instance_method(method_name).arity == 0 ||
+          instance_method(method_name).arity == -1
+        )
       end
 
+      before(:each) {setup}
+      after(:each) {teardown}
+
       def initialize(defined_description, options={}, &implementation)
         @_defined_description = defined_description
         
@@ -51,9 +49,13 @@ module Test
         @_implementation = implementation || pending_implementation
 
         @_result = ::Test::Unit::TestResult.new
-        # @method_name is important to set here because it "complies" with Test::Unit's interface.
+        # @method_name is important to set here because it complies with Test::Unit's interface.
         # 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
       end
 
       def run(ignore_this_argument=nil)

data/lib/spec/matchers/be_close.rb

@@ -1,37 +1,21 @@
 module Spec
   module Matchers
 
-    class BeClose #:nodoc:
-      def initialize(expected, delta)
-        @expected = expected
-        @delta = delta
-      end
-      
-      def matches?(given)
-        @given = given
-        (@given - @expected).abs < @delta
-      end
-      
-      def failure_message
-        "expected #{@expected} +/- (< #{@delta}), got #{@given}"
-      end
-      
-      def description
-        "be close to #{@expected} (within +- #{@delta})"
-      end
-    end
-    
     # :call-seq:
     #   should be_close(expected, delta)
     #   should_not be_close(expected, delta)
     #
-    # Passes if given == expected +/- delta
+    # Passes if actual == expected +/- delta
     #
     # == Example
     #
     #   result.should be_close(3.0, 0.5)
     def be_close(expected, delta)
-      Matchers::BeClose.new(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
     end
   end
 end

data/lib/spec/matchers/eql.rb

@@ -1,34 +1,11 @@
 module Spec
   module Matchers
   
-    class Eql #:nodoc:
-      def initialize(expected)
-        @expected = expected
-      end
-  
-      def matches?(given)
-        @given = given
-        @given.eql?(@expected)
-      end
-
-      def failure_message
-        return "expected #{@expected.inspect}, got #{@given.inspect} (using .eql?)", @expected, @given
-      end
-      
-      def negative_failure_message
-        return "expected #{@given.inspect} not to equal #{@expected.inspect} (using .eql?)", @expected, @given
-      end
-
-      def description
-        "eql #{@expected.inspect}"
-      end
-    end
-    
     # :call-seq:
     #   should eql(expected)
     #   should_not eql(expected)
     #
-    # Passes if given and expected are of equal value, but not necessarily the same object.
+    # Passes if actual and expected are of equal value, but not necessarily the same object.
     #
     # See http://www.ruby-doc.org/core/classes/Object.html#M001057 for more information about equality in Ruby.
     #
@@ -37,7 +14,12 @@ module Spec
     #   5.should eql(5)
     #   5.should_not eql(3)
     def eql(expected)
-      Matchers::Eql.new(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
     end
   end
 end

data/lib/spec/matchers/equal.rb

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

data/lib/spec/matchers/errors.rb

@@ -0,0 +1,5 @@
+module Spec
+  module Matchers
+    class MatcherError < StandardError; end
+  end
+end

data/lib/spec/matchers/exist.rb

@@ -1,22 +1,16 @@
 module Spec
   module Matchers
-    class Exist
-      def matches?(given)
-        @given = given
-        @given.exist?
-      end
-      def failure_message
-        "expected #{@given.inspect} to exist, but it doesn't."
-      end
-      def negative_failure_message
-        "expected #{@given.inspect} to not exist, but it does."
-      end
-    end
     # :call-seq:
     #   should exist
     #   should_not exist
     #
-    # Passes if given.exist?
-    def exist; Exist.new; end
+    # 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
+    end
   end
 end