rspec 1.1.11 → 1.1.12

data/lib/spec/matchers/throw_symbol.rb

@@ -2,39 +2,60 @@ module Spec
   module Matchers
     
     class ThrowSymbol #:nodoc:
-      def initialize(expected=nil)
-        @expected = expected
-        @actual = nil
+      def initialize(expected_symbol = nil, expected_arg=nil)
+        @expected_symbol = expected_symbol
+        @expected_arg = expected_arg
+        @caught_symbol = nil
       end
       
       def matches?(given_proc)
         begin
-          given_proc.call
-        rescue NameError => e
-          raise e unless e.message =~ /uncaught throw/
-          @actual = e.name.to_sym
+          if @expected_symbol.nil?
+            given_proc.call
+          else
+            @caught_arg = catch :proc_did_not_throw_anything do
+              catch @expected_symbol do
+                given_proc.call
+                throw :proc_did_not_throw_anything, :nothing_thrown
+              end
+            end
+            @caught_symbol = @expected_symbol unless @caught_arg == :nothing_thrown
+          end
+
+        # Ruby 1.8 uses NameError with `symbol'
+        # Ruby 1.9 uses ArgumentError with :symbol
+        rescue NameError, ArgumentError => e
+          raise e unless e.message =~ /uncaught throw (`|\:)([a-zA-Z0-9_]*)(')?/
+          @caught_symbol = $2.to_sym
+
         ensure
-          if @expected.nil?
-            return @actual.nil? ? false : true
+          if @expected_symbol.nil?
+            return !@caught_symbol.nil?
           else
-            return @actual == @expected
+            if @expected_arg.nil?
+              return @caught_symbol == @expected_symbol
+            else
+              # puts [@caught_symbol, @expected_symbol].inspect
+              # puts [@caught_arg, @expected_arg].inspect
+              return @caught_symbol == @expected_symbol && @caught_arg == @expected_arg
+            end
           end
         end
       end
 
       def failure_message
-        if @actual
-          "expected #{expected}, got #{@actual.inspect}"
+        if @caught_symbol
+          "expected #{expected}, got #{@caught_symbol.inspect}"
         else
           "expected #{expected} but nothing was thrown"
         end
       end
       
       def negative_failure_message
-        if @expected
+        if @expected_symbol
           "expected #{expected} not to be thrown"
         else
-          "expected no Symbol, got :#{@actual}"
+          "expected no Symbol, got :#{@caught_symbol}"
         end
       end
       
@@ -45,7 +66,11 @@ module Spec
       private
       
         def expected
-          @expected.nil? ? "a Symbol" : @expected.inspect
+          @expected_symbol.nil? ? "a Symbol" : "#{@expected_symbol.inspect}#{args}"
+        end
+        
+        def args
+          @expected_arg.nil? ? "" : " with #{@expected_arg.inspect}"
         end
       
     end
@@ -53,20 +78,27 @@ module Spec
     # :call-seq:
     #   should throw_symbol()
     #   should throw_symbol(:sym)
+    #   should throw_symbol(:sym, arg)
     #   should_not throw_symbol()
     #   should_not throw_symbol(:sym)
-    #
-    # Given a Symbol argument, matches if the given proc throws the specified Symbol.
+    #   should_not throw_symbol(:sym, arg)
     #
     # Given no argument, matches if a proc throws any Symbol.
     #
+    # Given a Symbol, matches if the given proc throws the specified Symbol.
+    #
+    # Given a Symbol and an arg, matches if the given proc throws the
+    # specified Symbol with the specified arg.
+    #
     # == Examples
     #
     #   lambda { do_something_risky }.should throw_symbol
     #   lambda { do_something_risky }.should throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should throw_symbol(:that_was_risky, culprit)
     #
     #   lambda { do_something_risky }.should_not throw_symbol
     #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky)
+    #   lambda { do_something_risky }.should_not throw_symbol(:that_was_risky, culprit)
     def throw_symbol(sym=nil)
       Matchers::ThrowSymbol.new(sym)
     end

data/lib/spec/matchers/wrap_expectation.rb

@@ -0,0 +1,55 @@
+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.failure_message = "expected #{mouse} 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/mocks/argument_constraints.rb

@@ -73,6 +73,25 @@ module Spec
         end
       end
       
+      class HashNotIncludingConstraint
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def ==(actual)
+          @expected.each do | key, value |
+            return false if actual.has_key?(key) && value == actual[key]
+          end
+          true
+        rescue NoMethodError => ex
+          return false
+        end
+
+        def description
+          "hash_not_including(#{@expected.inspect.sub(/^\{/,"").sub(/\}$/,"")})"
+        end
+      end
+      
       class DuckTypeConstraint
         def initialize(*methods_to_respond_to)
           @methods_to_respond_to = methods_to_respond_to
@@ -102,6 +121,26 @@ module Spec
           @given == expected
         end
       end
+      
+      class InstanceOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.instance_of?(@klass)
+        end
+      end
+      
+      class KindOf
+        def initialize(klass)
+          @klass = klass
+        end
+        
+        def ==(actual)
+          actual.kind_of?(@klass)
+        end
+      end
 
       # :call-seq:
       #   object.should_receive(:message).with(any_args())
@@ -153,12 +192,45 @@ module Spec
       end
       
       # :call-seq:
-      #   object.should_receive(:message).with(hash_including(:this => that))
-      #
-      # Passes if the argument is a hash that includes the specified key/value
+      #   object.should_receive(:message).with(hash_including(:key => val))
+      #   object.should_receive(:message).with(hash_including(:key))
+      #   object.should_receive(:message).with(hash_including(:key, :key2 => val2))
+      # Passes if the argument is a hash that includes the specified key(s) or key/value
       # pairs. If the hash includes other keys, it will still pass.
-      def hash_including(expected={})
-        HashIncludingConstraint.new(expected)
+      def hash_including(*args)
+        HashIncludingConstraint.new(anythingize_lonely_keys(*args))
+      end
+      
+      # :call-seq:
+      #   object.should_receive(:message).with(hash_not_including(:key => val))
+      #   object.should_receive(:message).with(hash_not_including(:key))
+      #   object.should_receive(:message).with(hash_not_including(:key, :key2 => :val2))
+      #
+      # Passes if the argument is a hash that doesn't include the specified key(s) or key/value
+      def hash_not_including(*args)
+        HashNotIncludingConstraint.new(anythingize_lonely_keys(*args))
+      end
+      
+      # Passes if arg.instance_of?(klass)
+      def instance_of(klass)
+        InstanceOf.new(klass)
+      end
+      
+      alias_method :an_instance_of, :instance_of
+      
+      # Passes if arg.kind_of?(klass)
+      def kind_of(klass)
+        KindOf.new(klass)
+      end
+      
+      alias_method :a_kind_of, :kind_of
+      
+      private
+      
+      def anythingize_lonely_keys(*args)
+        hash = args.last.class == Hash ? args.delete_at(-1) : {}
+        args.each { | arg | hash[arg] = anything }
+        hash
       end
     end
   end

data/lib/spec/mocks/message_expectation.rb

@@ -32,6 +32,7 @@ module Spec
         child.expected_from = expected_from
         child.method_block = method_block
         child.expected_received_count = expected_received_count
+        child.clear_actual_received_count!
         new_gen = error_generator.clone
         new_gen.opts = opts
         child.error_generator = new_gen
@@ -39,11 +40,6 @@ module Spec
         child
       end
       
-      def error_generator_opts=(opts={})
-        @error_generator.opts = opts
-      end
-      protected :error_generator_opts=
-      
       def expected_args
         @args_expectation.args
       end
@@ -92,7 +88,7 @@ module Spec
         @args_to_yield << args
         self
       end
-  
+      
       def matches(sym, args)
         @sym == sym and @args_expectation.args_match?(args)
       end
@@ -196,7 +192,7 @@ module Spec
         @sym == sym and not @args_expectation.args_match?(args)
       end
        
-      def verify_messages_received   
+      def verify_messages_received
         return if expected_messages_received? || failed_fast?
     
         generate_error
@@ -314,6 +310,10 @@ module Spec
               2
           end
         end
+        
+        def clear_actual_received_count!
+          @actual_received_count = 0
+        end
       
     end
     

data/lib/spec/mocks/proxy.rb

@@ -60,7 +60,7 @@ module Spec
         @stubs.unshift MessageExpectation.new(@error_generator, @expectation_ordering, expected_from, sym, nil, :any, opts)
         @stubs.first
       end
-
+      
       def verify #:nodoc:
         verify_expectations
       ensure
@@ -91,14 +91,14 @@ module Spec
           if expectation = find_almost_matching_expectation(sym, *args)
             expectation.advise(args, block) unless expectation.expected_messages_received?
           end
-          stub.invoke([], block)
+          stub.invoke(args, block)
         elsif expectation
           expectation.invoke(args, block)
         elsif expectation = find_almost_matching_expectation(sym, *args)
           expectation.advise(args, block) if null_object? unless expectation.expected_messages_received?
           raise_unexpected_message_args_error(expectation, *args) unless (has_negative_expectation?(sym) or null_object?)
         else
-          @target.send :method_missing, sym, *args, &block
+          @target.__send__ :method_missing, sym, *args, &block
         end
       end
 
@@ -125,14 +125,16 @@ module Spec
       
       def define_expected_method(sym)
         visibility_string = "#{visibility(sym)} :#{sym}"
-        if target_responds_to?(sym) && !target_metaclass.method_defined?(munge(sym))
-          munged_sym = munge(sym)
-          target_metaclass.instance_eval do
-            alias_method munged_sym, sym if method_defined?(sym.to_s)
+        unless @proxied_methods.include?(sym)
+          if target_responds_to?(sym)
+            munged_sym = munge(sym)
+            target_metaclass.instance_eval do
+              alias_method munged_sym, sym if method_defined?(sym.to_s)
+            end
+            @proxied_methods << sym
           end
-          @proxied_methods << sym
         end
-        
+
         target_metaclass.class_eval(<<-EOF, __FILE__, __LINE__)
           def #{sym}(*args, &block)
             __mock_proxy.message_received :#{sym}, *args, &block
@@ -142,9 +144,9 @@ module Spec
       end
 
       def target_responds_to?(sym)
-        return @target.send(munge(:respond_to?),sym) if @already_proxied_respond_to
+        return @target.__send__(munge(:respond_to?),sym) if @already_proxied_respond_to
         return @already_proxied_respond_to = true if sym == :respond_to?
-        return @target.respond_to?(sym)
+        return @target.respond_to?(sym, true)
       end
 
       def visibility(sym)
@@ -193,7 +195,7 @@ module Spec
               alias_method sym, munged_sym
               undef_method munged_sym
             else
-              undef_method sym
+              remove_method sym
             end
           end
         end

data/lib/spec/rake/spectask.rb

@@ -56,12 +56,10 @@ module Spec
     #   end
     #
     class SpecTask < ::Rake::TaskLib
-      class << self
-        def attr_accessor(*names)
-          super(*names)
-          names.each do |name|
-            module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs
-          end
+      def self.attr_accessor(*names)
+        super(*names)
+        names.each do |name|
+          module_eval "def #{name}() evaluate(@#{name}) end" # Allows use of procs
         end
       end
 

data/lib/spec/ruby.rb

@@ -0,0 +1,9 @@
+module Spec
+  module Ruby
+    class << self
+      def version
+        RUBY_VERSION
+      end
+    end
+  end
+end

data/lib/spec/runner.rb

@@ -1,3 +1,4 @@
+require 'spec/runner/configuration'
 require 'spec/runner/options'
 require 'spec/runner/option_parser'
 require 'spec/runner/example_group_runner'
@@ -9,166 +10,22 @@ require 'spec/runner/spec_parser'
 require 'spec/runner/class_and_arguments_parser'
 
 module Spec
-  # == ExampleGroups and Examples
-  # 
-  # Rather than expressing examples in classes, RSpec uses a custom DSLL (DSL light) to 
-  # describe groups of examples.
-  # 
-  # A ExampleGroup is the equivalent of a fixture in xUnit-speak. It is a metaphor for the context
-  # in which you will run your executable example - a set of known objects in a known starting state.
-  # We begin be describing
-  # 
-  #   describe Account do
-  # 
-  #     before do
-  #       @account = Account.new
-  #     end
-  # 
-  #     it "should have a balance of $0" do
-  #       @account.balance.should == Money.new(0, :dollars)
-  #     end
-  # 
-  #   end
-  # 
-  # We use the before block to set up the Example (given), and then the #it method to
-  # hold the example code that expresses the event (when) and the expected outcome (then).
-  # 
-  # == Helper Methods
-  # 
-  # A primary goal of RSpec is to keep the examples clear. We therefore prefer
-  # less indirection than you might see in xUnit examples and in well factored, DRY production code. We feel
-  # that duplication is OK if removing it makes it harder to understand an example without
-  # having to look elsewhere to understand its context.
-  # 
-  # That said, RSpec does support some level of encapsulating common code in helper
-  # methods that can exist within a context or within an included module.
-  # 
-  # == Setup and Teardown
-  # 
-  # You can use before and after within a Example. Both methods take an optional
-  # scope argument so you can run the block before :each example or before :all examples
-  # 
-  #   describe "..." do
-  #     before :all do
-  #       ...
-  #     end
-  # 
-  #     before :each do
-  #       ...
-  #     end
-  # 
-  #     it "should do something" do
-  #       ...
-  #     end
-  # 
-  #     it "should do something else" do
-  #       ...
-  #     end
-  # 
-  #     after :each do
-  #       ...
-  #     end
-  # 
-  #     after :all do
-  #       ...
-  #     end
-  # 
-  #   end
-  # 
-  # The <tt>before :each</tt> block will run before each of the examples, once for each example. Likewise,
-  # the <tt>after :each</tt> block will run after each of the examples.
-  # 
-  # It is also possible to specify a <tt>before :all</tt> and <tt>after :all</tt>
-  # block that will run only once for each behaviour, respectively before the first <code>before :each</code>
-  # and after the last <code>after :each</code>. The use of these is generally discouraged, because it
-  # introduces dependencies between the examples. Still, it might prove useful for very expensive operations
-  # if you know what you are doing.
-  # 
-  # == Local helper methods
-  # 
-  # You can include local helper methods by simply expressing them within a context:
-  # 
-  #   describe "..." do
-  #   
-  #     it "..." do
-  #       helper_method
-  #     end
-  # 
-  #     def helper_method
-  #       ...
-  #     end
-  # 
-  #   end
-  # 
-  # == Included helper methods
-  # 
-  # You can include helper methods in multiple contexts by expressing them within
-  # a module, and then including that module in your context:
-  # 
-  #   module AccountExampleHelperMethods
-  #     def helper_method
-  #       ...
-  #     end
-  #   end
-  # 
-  #   describe "A new account" do
-  #     include AccountExampleHelperMethods
-  #     before do
-  #       @account = Account.new
-  #     end
-  # 
-  #     it "should have a balance of $0" do
-  #       helper_method
-  #       @account.balance.should eql(Money.new(0, :dollars))
-  #     end
-  #   end
-  # 
-  # == Shared Example Groups
-  # 
-  # You can define a shared Example Group, that may be used on other groups
-  #
-  #  share_examples_for "All Editions" do
-  #    it "all editions behaviour" ...
-  #  end
-  #
-  #  describe SmallEdition do
-  #    it_should_behave_like "All Editions"
-  #  
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
-  #
-  # You can also assign the shared group to a module and include that
-  #
-  #  share_as :AllEditions do
-  #    it "should do all editions stuff" ...
-  #  end
-  #
-  #  describe SmallEdition do
-  #    it_should_behave_like AllEditions
-  #  
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
-  #
-  # And, for those of you who prefer to use something more like Ruby, you
-  # can just include the module directly
-  #
-  #  describe SmallEdition do
-  #    include AllEditions
-  #  
-  #    it "should do small edition stuff" do
-  #      ...
-  #    end
-  #  end
   module Runner
+    
+    class ExampleGroupCreationListener
+      def register_example_group(klass)
+        Spec::Runner.options.add_example_group klass
+        Spec::Runner.register_at_exit_hook
+      end
+    end
+    
+    Spec::Example::ExampleGroupMethods.example_group_creation_listeners << ExampleGroupCreationListener.new
+    
     class << self
       def configuration # :nodoc:
-        @configuration ||= Spec::Example::Configuration.new
+        @configuration ||= Spec::Runner::Configuration.new
       end
-      
+
       # Use this to configure various configurable aspects of
       # RSpec:
       #
@@ -177,19 +34,19 @@ module Spec
       #   end
       #
       # The yielded <tt>configuration</tt> object is a
-      # Spec::Example::Configuration instance. See its RDoc
+      # Spec::Runner::Configuration instance. See its RDoc
       # for details about what you can do with it.
       #
       def configure
         yield configuration
       end
-      
+    
       def register_at_exit_hook # :nodoc:
         unless @already_registered_at_exit_hook
           at_exit do
-            unless $! || Spec.run? || Spec::Example::ExampleGroupFactory.all_registered?(options.example_groups)
-              success = Spec.run
-              exit success if Spec.exit?
+            unless $! || run? || Spec::Example::ExampleGroupFactory.registered_or_ancestor_of_registered?(options.example_groups)
+              success = run
+              exit success if exit?
             end
           end
           @already_registered_at_exit_hook = true
@@ -203,11 +60,29 @@ module Spec
           parser.options
         end
       end
-      
+    
       def use options
         @options = options
       end
 
+      def test_unit_defined?
+        Object.const_defined?(:Test) && Test.const_defined?(:Unit) && Test::Unit.respond_to?(:run?)
+      end
+
+      def run?
+        Runner.options.examples_run?
+      end
+
+      def run
+        return true if run?
+        options.run_examples
+      end
+
+      def exit?
+        !test_unit_defined? || Test::Unit.run?
+      end
     end
   end
 end
+
+require 'spec/interop/test' if Spec::Runner::test_unit_defined?