ceedling 0.29.1 → 0.30.0

data/vendor/hardmock/lib/hardmock/errors.rb

@@ -1,22 +1,22 @@
-module Hardmock
-  # Raised when:
-  # * Unexpected method is called on a mock object
-  # * Bad arguments passed to an expected call
-  class ExpectationError < StandardError #:nodoc:#
-  end 
-
-  # Raised for methods that should no longer be called.  Hopefully, the exception message contains helpful alternatives.
-  class DeprecationError < StandardError #:nodoc:#
-  end 
-
-  # Raised when stubbing fails
-  class StubbingError < StandardError #:nodoc:#
-  end
-
-  # Raised when it is discovered that an expected method call was never made.
-  class VerifyError < StandardError #:nodoc:#
-    def initialize(msg,unmet_expectations)
-      super("#{msg}:" + unmet_expectations.map { |ex| "\n * #{ex.to_s}" }.join)
-    end
-  end
-end
+module Hardmock
+  # Raised when:
+  # * Unexpected method is called on a mock object
+  # * Bad arguments passed to an expected call
+  class ExpectationError < StandardError #:nodoc:#
+  end 
+
+  # Raised for methods that should no longer be called.  Hopefully, the exception message contains helpful alternatives.
+  class DeprecationError < StandardError #:nodoc:#
+  end 
+
+  # Raised when stubbing fails
+  class StubbingError < StandardError #:nodoc:#
+  end
+
+  # Raised when it is discovered that an expected method call was never made.
+  class VerifyError < StandardError #:nodoc:#
+    def initialize(msg,unmet_expectations)
+      super("#{msg}:" + unmet_expectations.map { |ex| "\n * #{ex.to_s}" }.join)
+    end
+  end
+end

data/vendor/hardmock/lib/hardmock/expectation.rb

@@ -1,229 +1,229 @@
-require 'hardmock/utils'
-
-module Hardmock
-  class Expectation
-    include Utils
-    attr_reader :block_value
-
-    def initialize(options) #:nodoc:
-      @options = options
-    end
-
-    def apply_method_call(mock,mname,args,block) #:nodoc:
-      unless @options[:mock].equal?(mock)
-        raise anger("Wrong object", mock,mname,args)
-      end
-      unless @options[:method] == mname
-        raise anger("Wrong method",mock,mname,args)
-      end
-
-      # Tester-defined block to invoke at method-call-time:
-      expectation_block = @options[:block]
-
-      expected_args = @options[:arguments]
-      # if we have a block, we can skip the argument check if none were specified
-      unless (expected_args.nil? || expected_args.empty?) && expectation_block && !@options[:suppress_arguments_to_block]
-        unless expected_args == args
-          raise anger("Wrong arguments",mock,mname,args)
-        end
-      end
-
-      relayed_args = args.dup
-      if block
-        if expectation_block.nil?
-          # Can't handle a runtime block without an expectation block
-          raise ExpectationError.new("Unexpected block provided to #{to_s}")
-        else
-          # Runtime blocks are passed as final argument to the expectation block
-          unless @options[:suppress_arguments_to_block]
-            relayed_args << block
-          else
-            # Arguments suppressed; send only the block
-            relayed_args = [block]
-          end
-        end
-      end
-
-      # Run the expectation block:
-      @block_value = expectation_block.call(*relayed_args) if expectation_block
-
-      raise @options[:raises] unless @options[:raises].nil?
-			
-			return_value = @options[:returns]
-			if return_value.nil?
-				return @block_value
-			else
-				return return_value
-			end
-    end
-
-    # Set the return value for an expected method call.
-    # Eg,
-    #   @cash_machine.expects.withdraw(20,:dollars).returns(20.00)
-    def returns(val)
-      @options[:returns] = val
-      self
-    end
-    alias_method :and_return, :returns
-    
-    # Set the arguments for an expected method call.
-    # Eg,
-    #   @cash_machine.expects.deposit.with(20, "dollars").returns(:balance => "20")
-    def with(*args)
-      @options[:arguments] = args
-      self      
-    end
-    
-    # Rig an expected method to raise an exception when the mock is invoked.
-    #
-    # Eg,
-    #   @cash_machine.expects.withdraw(20,:dollars).raises "Insufficient funds"
-    #
-    # The argument can be:
-    # * an Exception -- will be used directly
-    # * a String -- will be used as the message for a RuntimeError
-    # * nothing -- RuntimeError.new("An Error") will be raised
-    def raises(err=nil)
-      case err
-      when Exception
-        @options[:raises] = err
-      when String
-        @options[:raises] = RuntimeError.new(err)
-      else
-        @options[:raises] = RuntimeError.new("An Error")
-      end
-      self
-    end
-
-    # Convenience method: assumes +block_value+ is set, and is set to a Proc
-    # (or anything that responds to 'call')
-    #
-    #   light_event = @traffic_light.trap.subscribe(:light_changes)
-    #
-    #   # This code will meet the expectation:
-    #   @traffic_light.subscribe :light_changes do |color|
-    #     puts color
-    #   end
-    #
-    # The color-handling block is now stored in <tt>light_event.block_value</tt>
-    #
-    # The block can be invoked like this:
-    #
-    #   light_event.trigger :red
-    # 
-    # See Mock#trap and Mock#expects for information on using expectation objects 
-    # after they are set.
-    #
-    def trigger(*block_arguments)
-      unless block_value
-        raise ExpectationError.new("No block value is currently set for expectation #{to_s}")
-      end
-      unless block_value.respond_to?(:call)
-        raise ExpectationError.new("Can't apply trigger to #{block_value} for expectation #{to_s}")
-      end
-      block_value.call *block_arguments
-    end
-
-    # Used when an expected method accepts a block at runtime.  
-    # When the expected method is invoked, the block passed to
-    # that method will be invoked as well.
-    #
-    # NOTE: ExpectationError will be thrown upon running the expected method
-    # if the arguments you set up in +yields+ do not properly match up with
-    # the actual block that ends up getting passed.
-    # 
-    # == Examples
-    # <b>Single invocation</b>: The block passed to +lock_down+ gets invoked
-    # once with no arguments:
-    #
-    #   @safe_zone.expects.lock_down.yields
-    #
-    #   # (works on code that looks like:)
-    #   @safe_zone.lock_down do 
-    #     # ... this block invoked once
-    #   end
-    # 
-    # <b>Multi-parameter blocks:</b> The block passed to +each_item+ gets
-    # invoked twice, with <tt>:item1</tt> the first time, and with
-    # <tt>:item2</tt> the second time:
-    # 
-    #   @fruit_basket.expects.each_with_index.yields [:apple,1], [:orange,2]
-    #
-    #   # (works on code that looks like:)
-    #   @fruit_basket.each_with_index do |fruit,index|
-    #     # ... this block invoked with fruit=:apple, index=1, 
-    #     # ... and then with fruit=:orange, index=2
-    #   end
-    #
-    # <b>Arrays can be passed as arguments too</b>... if the block 
-    # takes a single argument and you want to pass a series of arrays into it,
-    # that will work as well:
-    #
-    #   @list_provider.expects.each_list.yields [1,2,3], [4,5,6]
-    #
-    #   # (works on code that looks like:)
-    #   @list_provider.each_list do |list|
-    #     # ... list is [1,2,3] the first time
-    #     # ... list is [4,5,6] the second time
-    #   end
-    #
-    # <b>Return value</b>: You can set the return value for the method that
-    # accepts the block like so: 
-    #
-    #   @cruncher.expects.do_things.yields(:bean1,:bean2).returns("The Results")
-    #
-    # <b>Raising errors</b>: You can set the raised exception for the method that
-    # accepts the block. NOTE: the error will be raised _after_ the block has
-    # been invoked.
-    #
-    #   # :bean1 and :bean2 will be passed to the block, then an error is raised:
-    #   @cruncher.expects.do_things.yields(:bean1,:bean2).raises("Too crunchy")
-    #
-    def yields(*items)
-      @options[:suppress_arguments_to_block] = true
-      if items.empty?
-        # Yield once
-        @options[:block] = lambda do |block|
-          if block.arity != 0 and block.arity != -1
-            raise ExpectationError.new("The given block was expected to have no parameter count; instead, got #{block.arity} to <#{to_s}>")
-          end
-          block.call
-        end
-      else
-        # Yield one or more specific items
-        @options[:block] = lambda do |block|
-          items.each do |item|
-            if item.kind_of?(Array) 
-              if block.arity == item.size
-                # Unfold the array into the block's arguments:
-                block.call *item
-              elsif block.arity == 1
-                # Just pass the array in
-                block.call item
-              else
-                # Size mismatch
-                raise ExpectationError.new("Can't pass #{item.inspect} to block with arity #{block.arity} to <#{to_s}>")
-              end
-            else
-              if block.arity != 1
-                # Size mismatch
-                raise ExpectationError.new("Can't pass #{item.inspect} to block with arity #{block.arity} to <#{to_s}>")
-              end
-              block.call item
-            end
-          end
-        end
-      end
-      self
-    end
-
-    def to_s # :nodoc:
-      format_method_call_string(@options[:mock],@options[:method],@options[:arguments])
-    end
-
-    private 
-    def anger(msg, mock,mname,args)
-      ExpectationError.new("#{msg}: expected call <#{to_s}> but was <#{format_method_call_string(mock,mname,args)}>")
-    end
-  end
-end
+require 'hardmock/utils'
+
+module Hardmock
+  class Expectation
+    include Utils
+    attr_reader :block_value
+
+    def initialize(options) #:nodoc:
+      @options = options
+    end
+
+    def apply_method_call(mock,mname,args,block) #:nodoc:
+      unless @options[:mock].equal?(mock)
+        raise anger("Wrong object", mock,mname,args)
+      end
+      unless @options[:method] == mname
+        raise anger("Wrong method",mock,mname,args)
+      end
+
+      # Tester-defined block to invoke at method-call-time:
+      expectation_block = @options[:block]
+
+      expected_args = @options[:arguments]
+      # if we have a block, we can skip the argument check if none were specified
+      unless (expected_args.nil? || expected_args.empty?) && expectation_block && !@options[:suppress_arguments_to_block]
+        unless expected_args == args
+          raise anger("Wrong arguments",mock,mname,args)
+        end
+      end
+
+      relayed_args = args.dup
+      if block
+        if expectation_block.nil?
+          # Can't handle a runtime block without an expectation block
+          raise ExpectationError.new("Unexpected block provided to #{to_s}")
+        else
+          # Runtime blocks are passed as final argument to the expectation block
+          unless @options[:suppress_arguments_to_block]
+            relayed_args << block
+          else
+            # Arguments suppressed; send only the block
+            relayed_args = [block]
+          end
+        end
+      end
+
+      # Run the expectation block:
+      @block_value = expectation_block.call(*relayed_args) if expectation_block
+
+      raise @options[:raises] unless @options[:raises].nil?
+			
+			return_value = @options[:returns]
+			if return_value.nil?
+				return @block_value
+			else
+				return return_value
+			end
+    end
+
+    # Set the return value for an expected method call.
+    # Eg,
+    #   @cash_machine.expects.withdraw(20,:dollars).returns(20.00)
+    def returns(val)
+      @options[:returns] = val
+      self
+    end
+    alias_method :and_return, :returns
+    
+    # Set the arguments for an expected method call.
+    # Eg,
+    #   @cash_machine.expects.deposit.with(20, "dollars").returns(:balance => "20")
+    def with(*args)
+      @options[:arguments] = args
+      self      
+    end
+    
+    # Rig an expected method to raise an exception when the mock is invoked.
+    #
+    # Eg,
+    #   @cash_machine.expects.withdraw(20,:dollars).raises "Insufficient funds"
+    #
+    # The argument can be:
+    # * an Exception -- will be used directly
+    # * a String -- will be used as the message for a RuntimeError
+    # * nothing -- RuntimeError.new("An Error") will be raised
+    def raises(err=nil)
+      case err
+      when Exception
+        @options[:raises] = err
+      when String
+        @options[:raises] = RuntimeError.new(err)
+      else
+        @options[:raises] = RuntimeError.new("An Error")
+      end
+      self
+    end
+
+    # Convenience method: assumes +block_value+ is set, and is set to a Proc
+    # (or anything that responds to 'call')
+    #
+    #   light_event = @traffic_light.trap.subscribe(:light_changes)
+    #
+    #   # This code will meet the expectation:
+    #   @traffic_light.subscribe :light_changes do |color|
+    #     puts color
+    #   end
+    #
+    # The color-handling block is now stored in <tt>light_event.block_value</tt>
+    #
+    # The block can be invoked like this:
+    #
+    #   light_event.trigger :red
+    # 
+    # See Mock#trap and Mock#expects for information on using expectation objects 
+    # after they are set.
+    #
+    def trigger(*block_arguments)
+      unless block_value
+        raise ExpectationError.new("No block value is currently set for expectation #{to_s}")
+      end
+      unless block_value.respond_to?(:call)
+        raise ExpectationError.new("Can't apply trigger to #{block_value} for expectation #{to_s}")
+      end
+      block_value.call *block_arguments
+    end
+
+    # Used when an expected method accepts a block at runtime.  
+    # When the expected method is invoked, the block passed to
+    # that method will be invoked as well.
+    #
+    # NOTE: ExpectationError will be thrown upon running the expected method
+    # if the arguments you set up in +yields+ do not properly match up with
+    # the actual block that ends up getting passed.
+    # 
+    # == Examples
+    # <b>Single invocation</b>: The block passed to +lock_down+ gets invoked
+    # once with no arguments:
+    #
+    #   @safe_zone.expects.lock_down.yields
+    #
+    #   # (works on code that looks like:)
+    #   @safe_zone.lock_down do 
+    #     # ... this block invoked once
+    #   end
+    # 
+    # <b>Multi-parameter blocks:</b> The block passed to +each_item+ gets
+    # invoked twice, with <tt>:item1</tt> the first time, and with
+    # <tt>:item2</tt> the second time:
+    # 
+    #   @fruit_basket.expects.each_with_index.yields [:apple,1], [:orange,2]
+    #
+    #   # (works on code that looks like:)
+    #   @fruit_basket.each_with_index do |fruit,index|
+    #     # ... this block invoked with fruit=:apple, index=1, 
+    #     # ... and then with fruit=:orange, index=2
+    #   end
+    #
+    # <b>Arrays can be passed as arguments too</b>... if the block 
+    # takes a single argument and you want to pass a series of arrays into it,
+    # that will work as well:
+    #
+    #   @list_provider.expects.each_list.yields [1,2,3], [4,5,6]
+    #
+    #   # (works on code that looks like:)
+    #   @list_provider.each_list do |list|
+    #     # ... list is [1,2,3] the first time
+    #     # ... list is [4,5,6] the second time
+    #   end
+    #
+    # <b>Return value</b>: You can set the return value for the method that
+    # accepts the block like so: 
+    #
+    #   @cruncher.expects.do_things.yields(:bean1,:bean2).returns("The Results")
+    #
+    # <b>Raising errors</b>: You can set the raised exception for the method that
+    # accepts the block. NOTE: the error will be raised _after_ the block has
+    # been invoked.
+    #
+    #   # :bean1 and :bean2 will be passed to the block, then an error is raised:
+    #   @cruncher.expects.do_things.yields(:bean1,:bean2).raises("Too crunchy")
+    #
+    def yields(*items)
+      @options[:suppress_arguments_to_block] = true
+      if items.empty?
+        # Yield once
+        @options[:block] = lambda do |block|
+          if block.arity != 0 and block.arity != -1
+            raise ExpectationError.new("The given block was expected to have no parameter count; instead, got #{block.arity} to <#{to_s}>")
+          end
+          block.call
+        end
+      else
+        # Yield one or more specific items
+        @options[:block] = lambda do |block|
+          items.each do |item|
+            if item.kind_of?(Array) 
+              if block.arity == item.size
+                # Unfold the array into the block's arguments:
+                block.call *item
+              elsif block.arity == 1
+                # Just pass the array in
+                block.call item
+              else
+                # Size mismatch
+                raise ExpectationError.new("Can't pass #{item.inspect} to block with arity #{block.arity} to <#{to_s}>")
+              end
+            else
+              if block.arity != 1
+                # Size mismatch
+                raise ExpectationError.new("Can't pass #{item.inspect} to block with arity #{block.arity} to <#{to_s}>")
+              end
+              block.call item
+            end
+          end
+        end
+      end
+      self
+    end
+
+    def to_s # :nodoc:
+      format_method_call_string(@options[:mock],@options[:method],@options[:arguments])
+    end
+
+    private 
+    def anger(msg, mock,mname,args)
+      ExpectationError.new("#{msg}: expected call <#{to_s}> but was <#{format_method_call_string(mock,mname,args)}>")
+    end
+  end
+end