rspec 1.1.3 → 1.1.4

data/lib/spec/example/example_group.rb

@@ -1,6 +1,7 @@
 module Spec
   module Example
-    # The superclass for all regular RSpec examples.
+    # Base class for customized example groups. Use this if you
+    # want to make a custom example group.
     class ExampleGroup
       extend Spec::Example::ExampleGroupMethods
       include Spec::Example::ExampleMethods

data/lib/spec/example/example_group_factory.rb

@@ -7,52 +7,54 @@ module Spec
           default(ExampleGroup)
         end
 
-        # Registers an example group class +klass+ with the symbol
-        # +type+. For example:
+        # Registers an example group class +klass+ with the symbol +type+. For
+        # example:
         #
-        #   Spec::Example::ExampleGroupFactory.register(:farm, Spec::Farm::Example::FarmExampleGroup)
+        #   Spec::Example::ExampleGroupFactory.register(:farm, FarmExampleGroup)
         #
-        # This will cause Main#describe from a file living in 
-        # <tt>spec/farm</tt> to create example group instances of type
-        # Spec::Farm::Example::FarmExampleGroup.
-        def register(id, example_group_class)
-          @example_group_types[id] = example_group_class
+        # With that you can append a hash with :type => :farm to the describe
+        # method and it will load an instance of FarmExampleGroup.
+        #
+        #   describe Pig, :type => :farm do
+        #     ...
+        #
+        # If you don't use the hash explicitly, <tt>describe</tt> will
+        # implicitly use an instance of FarmExampleGroup for any file loaded
+        # from the <tt>./spec/farm</tt> directory.
+        def register(key, example_group_class)
+          @example_group_types[key] = example_group_class
         end
         
         # Sets the default ExampleGroup class
         def default(example_group_class)
           old = @example_group_types
           @example_group_types = Hash.new(example_group_class)
-          @example_group_types.merge(old) if old
+          @example_group_types.merge!(old) if old
         end
 
-        def get(id=nil)
-          if @example_group_types.values.include?(id)
-            id
+        def get(key=nil)
+          if @example_group_types.values.include?(key)
+            key
           else
-            @example_group_types[id]
+            @example_group_types[key]
           end
         end
         
         def create_example_group(*args, &block)
           opts = Hash === args.last ? args.last : {}
-          if opts[:shared]
-            SharedExampleGroup.new(*args, &block)
-          else
-            superclass = determine_superclass(opts)
-            superclass.describe(*args, &block)
-          end
+          superclass = determine_superclass(opts)
+          superclass.describe(*args, &block)
         end
 
         protected
 
         def determine_superclass(opts)
-          id = if opts[:type]
+          key = if opts[:type]
             opts[:type]
           elsif opts[:spec_path] =~ /spec(\\|\/)(#{@example_group_types.keys.join('|')})/
             $2 == '' ? nil : $2.to_sym
           end
-          get(id)
+          get(key)
         end
 
       end

data/lib/spec/example/example_group_methods.rb

@@ -34,10 +34,17 @@ module Spec
       #   end
       #
       def describe(*args, &example_group_block)
+        args << {} unless Hash === args.last
         if example_group_block
-          self.subclass("Subclass") do
-            describe(*args)
-            module_eval(&example_group_block)
+          params = args.last
+          params[:spec_path] = eval("caller(0)[1]", example_group_block) unless params[:spec_path]
+          if params[:shared]
+            SharedExampleGroup.new(*args, &example_group_block)
+          else
+            self.subclass("Subclass") do
+              describe(*args)
+              module_eval(&example_group_block)
+            end
           end
         else
           set_description(*args)
@@ -45,6 +52,7 @@ module Spec
           self
         end
       end
+      alias :context :describe
 
       # Use this to pull in examples from shared example groups.
       # See Spec::Runner for information about shared example groups.
@@ -107,11 +115,12 @@ module Spec
       def xit(description=nil, opts={}, &block)
         Kernel.warn("Example disabled: #{description}")
       end
+      alias_method :xspecify, :xit
 
       def run
         examples = examples_to_run
-        return true if examples.empty?
         reporter.add_example_group(self)
+        return true if examples.empty?
         return dry_run(examples) if dry_run?
 
         plugin_mock_framework
@@ -150,10 +159,12 @@ module Spec
         @description_text = ExampleGroupMethods.description_text(*args)
         @spec_path = File.expand_path(options[:spec_path]) if options[:spec_path]
         if described_type.class == Module
-          include described_type
+          @described_module = described_type
         end
         self
       end
+      
+      attr_reader :described_module
 
       def examples #:nodoc:
         examples = example_objects.dup
@@ -384,6 +395,7 @@ module Spec
         case scope
         when :each; before_each_parts
         when :all; before_all_parts
+        when :suite; rspec_options.before_suite_parts
         end
       end
 
@@ -391,6 +403,7 @@ module Spec
         case scope
         when :each; after_each_parts
         when :all; after_all_parts
+        when :suite; rspec_options.after_suite_parts
         end
       end
 

data/lib/spec/example/example_methods.rb

@@ -3,6 +3,8 @@ module Spec
     module ExampleMethods
       extend ExampleGroupMethods
       extend ModuleReopeningFix
+      include ModuleInclusionWarnings
+      
 
       PENDING_EXAMPLE_BLOCK = lambda {
         raise Spec::Example::ExamplePendingError.new("Not Yet Implemented")
@@ -63,6 +65,10 @@ module Spec
       def description
         @_defined_description || @_matcher_description || "NO NAME"
       end
+
+      def __full_description
+        "#{self.class.description} #{self.description}"
+      end
       
       def set_instance_variables_from_hash(ivars)
         ivars.each do |variable_name, value|

data/lib/spec/example/module_inclusion_warnings.rb

@@ -0,0 +1,37 @@
+module Spec
+  module Example
+    # In the future, modules will no longer be automatically included
+    # in the Example Group (based on the description name); when that 
+    # time comes, this code should be removed.
+    module ModuleInclusionWarnings
+      # Thanks, Francis Hwang.
+      class MethodDispatcher
+        def initialize(mod, target=nil)
+          @mod = mod
+          @target = target
+        end
+        
+        def respond_to?(sym)
+          @mod && @mod.instance_methods.include?(sym.to_s)
+        end
+        
+        def call(sym, *args, &blk)
+          Kernel.warn("Modules will no longer be automatically included in RSpec version 1.1.4.  Called from #{caller[2]}")
+          @target.extend @mod
+          @target.send(sym, *args, &blk)
+        end
+      end
+      
+      def respond_to?(sym)
+        MethodDispatcher.new(self.class.described_module).respond_to?(sym) ? true : super
+      end
+      
+    private
+      
+      def method_missing(sym, *args, &blk)
+        md = MethodDispatcher.new(self.class.described_module, self)
+        self.respond_to?(sym) ? md.call(sym, *args, &blk) : super
+      end
+    end
+  end
+end

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

@@ -17,7 +17,7 @@ module Spec
         end
 
         # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
-        def diff_as_string(data_old, data_new)
+        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 = ""

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

@@ -27,12 +27,8 @@ module Spec
       #
       # NOTE that this does NOT support receiver.should != expected.
       # Instead, use receiver.should_not == expected
-      def should(matcher = :default_parameter, &block)
-        if :default_parameter == matcher
-          Spec::Matchers::PositiveOperatorMatcher.new(self)
-        else
-          ExpectationMatcherHandler.handle_matcher(self, matcher, &block)
-        end
+      def should(matcher=:use_operator_matcher, &block)
+        ExpectationMatcherHandler.handle_matcher(self, matcher, &block)
       end
 
       # :call-seq:
@@ -54,12 +50,8 @@ module Spec
       #     => Passes unless (receiver =~ regexp)
       #
       # See Spec::Matchers for more information about matchers
-      def should_not(matcher = :default_parameter, &block)
-        if :default_parameter == matcher
-          Spec::Matchers::NegativeOperatorMatcher.new(self)
-        else
-          NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
-        end
+      def should_not(matcher=:use_operator_matcher, &block)
+        NegativeExpectationMatcherHandler.handle_matcher(self, matcher, &block)
       end
 
     end

data/lib/spec/expectations/handler.rb

@@ -12,6 +12,10 @@ module Spec
       class << self
         include MatcherHandlerHelper
         def handle_matcher(actual, matcher, &block)
+          if :use_operator_matcher == matcher
+            return Spec::Matchers::PositiveOperatorMatcher.new(actual)
+          end
+
           unless matcher.respond_to?(:matches?)
             raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
           end
@@ -27,6 +31,10 @@ module Spec
       class << self
         include MatcherHandlerHelper
         def handle_matcher(actual, matcher, &block)
+          if :use_operator_matcher == matcher
+            return Spec::Matchers::NegativeOperatorMatcher.new(actual)
+          end
+          
           unless matcher.respond_to?(:matches?)
             raise InvalidMatcherError, "Expected a matcher, got #{matcher.inspect}."
           end

data/lib/spec/extensions.rb

@@ -1,3 +1,4 @@
 require 'spec/extensions/object'
 require 'spec/extensions/class'
 require 'spec/extensions/main'
+require 'spec/extensions/metaclass'

data/lib/spec/extensions/metaclass.rb

@@ -0,0 +1,7 @@
+module Spec
+  module MetaClass
+    def metaclass
+      class << self; self; end
+    end
+  end
+end

data/lib/spec/extensions/object.rb

@@ -3,8 +3,4 @@ class Object
     options = Hash === args.last ? args.pop : {}
     return args, options
   end
-
-  def metaclass
-    class << self; self; end
-  end
 end

data/lib/spec/matchers/change.rb

@@ -114,7 +114,7 @@ EOF
     #
     #   string = "string"
     #   lambda {
-    #     string.reverse
+    #     string.reverse!
     #   }.should change { string }.from("string").to("gnirts")
     #
     #   lambda {

data/lib/spec/matchers/has.rb

@@ -8,24 +8,14 @@ module Spec
       end
       
       def matches?(target)
-        @target = target
-        begin
-          return target.send(predicate, *@args)
-        rescue => @error
-          # This clause should be empty, but rcov will not report it as covered
-          # unless something (anything) is executed within the clause
-          rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
-        end
-        return false
+        target.send(predicate, *@args)
       end
       
       def failure_message
-        raise @error if @error
         "expected ##{predicate}(#{@args[0].inspect}) to return true, got false"
       end
       
       def negative_failure_message
-        raise @error if @error
         "expected ##{predicate}(#{@args[0].inspect}) to return false, got true"
       end
       

data/lib/spec/matchers/raise_error.rb

@@ -1,54 +1,66 @@
 module Spec
   module Matchers
-    
     class RaiseError #:nodoc:
-      def initialize(error_or_message=Exception, message=nil)
-        if String === error_or_message
-          @expected_error = Exception
-          @expected_message = error_or_message
+      def initialize(error_or_message=Exception, message=nil, &block)
+        @block = block
+        case error_or_message
+        when String, Regexp
+          @expected_error, @expected_message = Exception, error_or_message
         else
-          @expected_error = error_or_message
-          @expected_message = message
+          @expected_error, @expected_message = error_or_message, message
         end
       end
-      
+
       def matches?(proc)
         @raised_expected_error = false
-        @raised_other = false
+        @with_expected_message = false
+        @eval_block = false
+        @eval_block_passed = false
         begin
           proc.call
         rescue @expected_error => @actual_error
-          if @expected_message.nil?
-            @raised_expected_error = true
-          else
-            verify_message
-          end
+          @raised_expected_error = true
+          @with_expected_message = verify_message
         rescue Exception => @actual_error
-          @raised_other = true
-        ensure
-          return @raised_expected_error
+          # This clause should be empty, but rcov will not report it as covered
+          # unless something (anything) is executed within the clause
+          rcov_error_report = "http://eigenclass.org/hiki.rb?rcov-0.8.0"
+        end
+
+        unless negative_expectation?
+          eval_block if @raised_expected_error && @with_expected_message && @block
+        end
+      ensure
+        return (@raised_expected_error && @with_expected_message) ? (@eval_block ? @eval_block_passed : true) : false
+      end
+      
+      def eval_block
+        @eval_block = true
+        begin
+          @block[@actual_error]
+          @eval_block_passed = true
+        rescue Exception => err
+          @actual_error = err
         end
       end
 
       def verify_message
         case @expected_message
+        when nil
+          return true
         when Regexp
-          if @expected_message =~ @actual_error.message
-            @raised_expected_error = true
-          else
-            @raised_other = true
-          end
+          return @expected_message =~ @actual_error.message
         else
-          if @expected_message == @actual_error.message
-            @raised_expected_error = true
-          else
-            @raised_other = true
-          end
+          return @expected_message == @actual_error.message
         end
       end
       
       def failure_message
-        return "expected #{expected_error}#{actual_error}" if @raised_other || !@raised_expected_error
+        if @eval_block
+          return @actual_error.message
+        else
+          return "expected #{expected_error}#{actual_error}"
+        end
       end
 
       def negative_failure_message
@@ -74,6 +86,11 @@ module Spec
         def actual_error
           @actual_error.nil? ? " but nothing was raised" : ", got #{@actual_error.inspect}"
         end
+        
+        def negative_expectation?
+          # YES - I'm a bad person... help me find a better way - ryand
+          caller.first(3).find { |s| s =~ /should_not/ }
+        end
     end
     
     # :call-seq:
@@ -81,6 +98,10 @@ module Spec
     #   should raise_error(NamedError)
     #   should raise_error(NamedError, String)
     #   should raise_error(NamedError, Regexp)
+    #   should raise_error() { |error| ... }
+    #   should raise_error(NamedError) { |error| ... }
+    #   should raise_error(NamedError, String) { |error| ... }
+    #   should raise_error(NamedError, Regexp) { |error| ... }
     #   should_not raise_error()
     #   should_not raise_error(NamedError)
     #   should_not raise_error(NamedError, String)
@@ -90,11 +111,13 @@ module Spec
     # With a named error, matches only if that specific error is raised.
     # With a named error and messsage specified as a String, matches only if both match.
     # With a named error and messsage specified as a Regexp, matches only if both match.
+    # Pass an optional block to perform extra verifications on the exception matched
     #
     # == Examples
     #
     #   lambda { do_something_risky }.should raise_error
     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError)
+    #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError) { |error| error.data.should == 42 }
     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, "that was too risky")
     #   lambda { do_something_risky }.should raise_error(PoorRiskDecisionError, /oo ri/)
     #
@@ -102,8 +125,8 @@ module Spec
     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError)
     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, "that was too risky")
     #   lambda { do_something_risky }.should_not raise_error(PoorRiskDecisionError, /oo ri/)
-    def raise_error(error=Exception, message=nil)
-      Matchers::RaiseError.new(error, message)
+    def raise_error(error=Exception, message=nil, &block)
+      Matchers::RaiseError.new(error, message, &block)
     end
   end
 end