rspec 1.1.11 → 1.1.12

data/lib/spec/example/example_methods.rb

@@ -4,6 +4,43 @@ module Spec
       
       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
+      
+      def violated(message="")
+        raise Spec::Expectations::ExpectationNotMetError.new(message)
+      end
+
+      def description
+        @_defined_description || ::Spec::Matchers.generated_description || "NO NAME"
+      end
+      
+      def options
+        @_options
+      end
+
       def execute(options, instance_variables)
         options.reporter.example_started(self)
         set_instance_variables_from_hash(instance_variables)
@@ -27,28 +64,24 @@ 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 violated(message="")
-        raise Spec::Expectations::ExpectationNotMetError.new(message)
-      end
-
-      def eval_each_fail_fast(procs) #:nodoc:
-        procs.each do |proc|
-          instance_eval(&proc)
+      def eval_each_fail_fast(examples) # :nodoc:
+        examples.each do |example|
+          instance_eval(&example)
         end
       end
 
-      def eval_each_fail_slow(procs) #:nodoc:
+      def eval_each_fail_slow(examples) # :nodoc:
         first_exception = nil
-        procs.each do |proc|
+        examples.each do |example|
           begin
-            instance_eval(&proc)
+            instance_eval(&example)
           rescue Exception => e
             first_exception ||= e
           end
@@ -56,19 +89,19 @@ module Spec
         raise first_exception if first_exception
       end
 
-      def description
-        @_defined_description || ::Spec::Matchers.generated_description || "NO NAME"
-      end
-      
-      def options
-        @_options
-      end
-
-      def __full_description
+      # 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}"
       end
       
-      def set_instance_variables_from_hash(ivars)
+      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)
@@ -77,15 +110,25 @@ module Spec
         end
       end
 
-      def eval_block
+      def eval_block # :nodoc:
         instance_eval(&@_implementation)
       end
 
-      def implementation_backtrace
-        eval("caller", @_implementation)
+      # Provides the backtrace up to where this example was declared.
+      def backtrace
+        @_backtrace
       end
       
-      protected
+      # 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
+
+      private
       include Matchers
       include Pending
       
@@ -100,6 +143,26 @@ module Spec
       ensure
         teardown_mocks_for_rspec
       end
+
+      def subject_variable_name
+        '@' << (described_class ? underscore(described_class.name) : '__this_does_not_exist')
+      end
+      
+      def described_class
+        Class === described_type ? described_type : nil
+      end
+      
+      def described_type
+        self.class.described_type
+      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
+      end
     end
   end
 end

data/lib/spec/example/shared_example_group.rb

@@ -2,31 +2,43 @@ module Spec
   module Example
     class SharedExampleGroup < Module
       module ClassMethods
-        def add_shared_example_group(new_example_group)
-          guard_against_redefining_existing_example_group(new_example_group)
-          shared_example_groups << new_example_group
+        def register(*args, &block)
+          new_example_group = new(*args, &block)
+          shared_example_groups << new_example_group unless already_registered?(new_example_group)
+          new_example_group
+        end
+        
+        def find(example_group_description)
+          shared_example_groups.find {|b| b.description == example_group_description}
         end
 
-        def find_shared_example_group(example_group_description)
-          shared_example_groups.find do |b|
-            b.description == example_group_description
-          end
+        def clear
+          shared_example_groups.clear
+        end
+        
+        def include?(group)
+          shared_example_groups.include?(group)
+        end
+        
+        def count
+          shared_example_groups.length
         end
 
+      private
+      
         def shared_example_groups
           @shared_example_groups ||= []
         end
-
-        private
-        def guard_against_redefining_existing_example_group(new_example_group)
-          existing_example_group = find_shared_example_group(new_example_group.description)
-          return unless existing_example_group
-          return if new_example_group.equal?(existing_example_group)
-          return if spec_path(new_example_group) == spec_path(existing_example_group)
+      
+        def already_registered?(new_example_group)
+          existing_example_group = find(new_example_group.description)
+          return false unless existing_example_group
+          return true if new_example_group.equal?(existing_example_group)
+          return true if expanded_path(new_example_group) == expanded_path(existing_example_group)
           raise ArgumentError.new("Shared Example '#{existing_example_group.description}' already exists")
         end
 
-        def spec_path(example_group)
+        def expanded_path(example_group)
           File.expand_path(example_group.spec_path)
         end
       end
@@ -35,18 +47,13 @@ module Spec
       include ExampleGroupMethods
 
       def initialize(*args, &example_group_block)
-        describe(*args)
+        set_description(*args)
         @example_group_block = example_group_block
-        self.class.add_shared_example_group(self)
       end
 
       def included(mod) # :nodoc:
         mod.module_eval(&@example_group_block)
       end
-
-      def each_ancestor_example_group_class(superclass_last=false)
-        yield self
-      end
     end
   end
 end

data/lib/spec/expectations.rb

@@ -30,27 +30,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/expectations/handler.rb

@@ -3,50 +3,30 @@ 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
+        ::Spec::Matchers.last_matcher = matcher
 
-          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
+        return ::Spec::Matchers::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+        match = matcher.matches?(actual, &block)
+        ::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
+        ::Spec::Matchers.last_matcher = matcher
 
-          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
+        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
       end
     end
-
   end
 end
 

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/interop/test/unit/testresult.rb

@@ -1,6 +1,6 @@
 class Test::Unit::TestResult
   alias_method :tu_passed?, :passed?
   def passed?
-    return tu_passed? & ::Spec.run
+    return tu_passed? & ::Spec::Runner.run
   end
 end

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

@@ -14,7 +14,7 @@ module Test
 
       def run(*args)
         return true unless args.empty?
-        example_group.run
+        example_group.run(Spec::Runner.options)
       end
 
       def size

data/lib/spec/matchers.rb

@@ -1,7 +1,12 @@
+require 'spec/matchers/operator_matcher'
+require 'spec/matchers/generated_descriptions'
+require 'spec/matchers/errors'
+require 'spec/matchers/method_missing'
 require 'spec/matchers/simple_matcher'
 require 'spec/matchers/be'
 require 'spec/matchers/be_close'
 require 'spec/matchers/change'
+require 'spec/matchers/match_array'
 require 'spec/matchers/eql'
 require 'spec/matchers/equal'
 require 'spec/matchers/exist'
@@ -13,7 +18,7 @@ require 'spec/matchers/raise_error'
 require 'spec/matchers/respond_to'
 require 'spec/matchers/satisfy'
 require 'spec/matchers/throw_symbol'
-require 'spec/matchers/operator_matcher'
+require 'spec/matchers/wrap_expectation'
 
 module Spec
 
@@ -132,31 +137,5 @@ module Spec
   #     config.include(CustomGameMatchers)
   #   end
   #
-  module Matchers
-    module ModuleMethods
-      attr_accessor :last_matcher, :last_should
-
-      def clear_generated_description
-        self.last_matcher = nil
-        self.last_should = nil
-      end
-      
-      def generated_description
-        last_should.nil? ? nil :
-          "#{last_should} #{last_matcher.respond_to?(:description) ? last_matcher.description : 'NO NAME'}"
-      end
-    end
-
-    extend ModuleMethods
-
-    def method_missing(sym, *args, &block) # :nodoc:
-      return Matchers::Be.new(sym, *args) if sym.starts_with?("be_")
-      return Matchers::Has.new(sym, *args) if sym.starts_with?("have_")
-      super
-    end
-
-    class MatcherError < StandardError
-    end
-    
-  end
+  module Matchers; end
 end