ceedling 0.29.0 → 0.30.0

data/vendor/hardmock/lib/hardmock/stubbing.rb

@@ -1,210 +1,210 @@
-
-
-# Stubbing support
-#
-# Stubs methods on classes and instances
-#
-
-# Why's "metaid.rb" stuff crunched down:
-class Object #:nodoc:#
-	def hm_metaclass #:nodoc:#
-    class << self
-      self
-    end
-  end
-	
-	def hm_meta_eval(&blk) #:nodoc:#
-    hm_metaclass.instance_eval(&blk)
-  end
-
-	def hm_meta_def(name, &blk) #:nodoc:#
-		hm_meta_eval { define_method name, &blk }
-	end
-end
-
-
-
-module Hardmock
-
-  # == Hardmock: Stubbing and Mocking Concrete Methods
-  #
-  # Hardmock lets you stub and/or mock methods on concrete classes or objects.
-  #
-  # * To "stub" a concrete method is to rig it to return the same thing always, disregarding any arguments.
-  # * To "mock" a concrete method is to surplant its funcionality by delegating to a mock object who will cover this behavior.
-  #
-  # Mocked methods have their expectations considered along with all other mock object expectations.
-  #
-  # If you use stubbing or concrete mocking in the absence (or before creation) of other mocks, you need to invoke <tt>prepare_hardmock_control</tt>.
-  # Once <tt>verify_mocks</tt> or <tt>clear_expectaions</tt> is called, the overriden behavior in the target objects is restored.
-  #
-  # == Examples
-  #
-  #   River.stubs!(:sounds_like).returns("gurgle")
-  #
-  #   River.expects!(:jump).returns("splash")
-  #
-  #   rogue.stubs!(:sounds_like).returns("pshshsh")
-  #
-  #   rogue.expects!(:rawhide_tanning_solvents).returns("giant snapping turtles")
-  #
-  module Stubbing
-    # Exists only for documentation 
-  end
-
-  class ReplacedMethod #:nodoc:#
-    attr_reader :target, :method_name
-
-    def initialize(target, method_name)
-      @target = target
-      @method_name = method_name
-
-      Hardmock.track_replaced_method self
-    end
-  end
-
-  class StubbedMethod < ReplacedMethod #:nodoc:#
-    def invoke(args)
-      raise @raises if @raises
-      @return_value
-    end
-
-    def returns(stubbed_return)
-      @return_value = stubbed_return
-    end
-
-    def raises(err)
-      err = RuntimeError.new(err) unless err.kind_of?(Exception)
-      @raises = err
-    end
-  end
-
-  class ::Object
-    def stubs!(method_name)
-      method_name = method_name.to_s
-      already_stubbed = Hardmock.has_replaced_method?(self, method_name)
-
-      stubbed_method = Hardmock::StubbedMethod.new(self, method_name)
-
-
-      unless _is_mock? or already_stubbed
-        if methods.include?(method_name.to_s)
-          hm_meta_eval do 
-            alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
-          end
-        end
-      end
-
-      hm_meta_def method_name do |*args|
-        stubbed_method.invoke(args)
-      end
-
-      stubbed_method
-    end
-
-    def expects!(method_name, *args, &block)
-      if self._is_mock?
-        raise Hardmock::StubbingError, "Cannot use 'expects!(:#{method_name})' on a Mock object; try 'expects' instead"
-      end
-
-      method_name = method_name.to_s
-
-      @_my_mock = Mock.new(_my_name, $main_mock_control) if @_my_mock.nil?
-
-      unless Hardmock.has_replaced_method?(self, method_name)
-        # Track the method as replaced
-        Hardmock::ReplacedMethod.new(self, method_name)
-
-        # Preserver original implementation of the method by aliasing it away
-        if methods.include?(method_name)
-          hm_meta_eval do 
-            alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
-          end
-        end
-
-        # Re-define the method to utilize our patron mock instance.
-        # (This global-temp-var thing is hokey but I was having difficulty generating 
-        # code for the meta class.)
-        begin
-          $method_text_temp = %{
-            def #{method_name}(*args,&block)
-              @_my_mock.__send__(:#{method_name}, *args, &block)
-            end
-          }
-          class << self
-            eval $method_text_temp
-          end
-        ensure
-          $method_text_temp = nil
-        end
-      end
-
-      return @_my_mock.expects(method_name, *args, &block)
-    end
-      
-    def _is_mock?
-      self.kind_of?(Mock)
-    end
-
-    def _my_name
-      self.kind_of?(Class) ? self.name : self.class.name
-    end
-
-    def _clear_mock
-      @_my_mock = nil
-    end
-
-  end
-
-  class ::NilClass
-    # Use this only if you really mean it
-    alias_method :intentionally_stubs!, :stubs!
-    
-    # Use this only if you really mean it
-    alias_method :intentionally_expects!, :expects!
-
-    # Overridden to protect against accidental nil reference self delusion 
-    def stubs!(mname)
-      raise StubbingError, "Cannot stub #{mname} method on nil.  (If you really mean to, try 'intentionally_stubs!')"
-    end
-
-    # Overridden to protect against accidental nil reference self delusion 
-    def expects!(mname, *args)
-      raise StubbingError, "Cannot mock #{mname} method on nil.  (If you really mean to, try 'intentionally_expects!')"
-    end
-  end
-
-  class << self
-    def track_replaced_method(replaced_method)
-      all_replaced_methods << replaced_method
-    end
-
-    def all_replaced_methods
-      $all_replaced_methods ||= []
-    end
-
-    def has_replaced_method?(obj, method_name)
-      hits = all_replaced_methods.select do |replaced|
-        (replaced.target.object_id == obj.object_id) and (replaced.method_name.to_s == method_name.to_s)
-      end
-      return !hits.empty?
-    end
-
-    def restore_all_replaced_methods
-      all_replaced_methods.each do |replaced|
-        unless replaced.target._is_mock?
-          backed_up = "_hardmock_original_#{replaced.method_name}"
-          if replaced.target.methods.include?(backed_up)
-            replaced.target.hm_meta_eval do
-              alias_method replaced.method_name.to_sym, backed_up.to_sym 
-            end
-          end
-          replaced.target._clear_mock
-        end
-      end
-      all_replaced_methods.clear
-    end
-  end
-
-end
-
+
+
+# Stubbing support
+#
+# Stubs methods on classes and instances
+#
+
+# Why's "metaid.rb" stuff crunched down:
+class Object #:nodoc:#
+	def hm_metaclass #:nodoc:#
+    class << self
+      self
+    end
+  end
+	
+	def hm_meta_eval(&blk) #:nodoc:#
+    hm_metaclass.instance_eval(&blk)
+  end
+
+	def hm_meta_def(name, &blk) #:nodoc:#
+		hm_meta_eval { define_method name, &blk }
+	end
+end
+
+
+
+module Hardmock
+
+  # == Hardmock: Stubbing and Mocking Concrete Methods
+  #
+  # Hardmock lets you stub and/or mock methods on concrete classes or objects.
+  #
+  # * To "stub" a concrete method is to rig it to return the same thing always, disregarding any arguments.
+  # * To "mock" a concrete method is to surplant its funcionality by delegating to a mock object who will cover this behavior.
+  #
+  # Mocked methods have their expectations considered along with all other mock object expectations.
+  #
+  # If you use stubbing or concrete mocking in the absence (or before creation) of other mocks, you need to invoke <tt>prepare_hardmock_control</tt>.
+  # Once <tt>verify_mocks</tt> or <tt>clear_expectaions</tt> is called, the overriden behavior in the target objects is restored.
+  #
+  # == Examples
+  #
+  #   River.stubs!(:sounds_like).returns("gurgle")
+  #
+  #   River.expects!(:jump).returns("splash")
+  #
+  #   rogue.stubs!(:sounds_like).returns("pshshsh")
+  #
+  #   rogue.expects!(:rawhide_tanning_solvents).returns("giant snapping turtles")
+  #
+  module Stubbing
+    # Exists only for documentation 
+  end
+
+  class ReplacedMethod #:nodoc:#
+    attr_reader :target, :method_name
+
+    def initialize(target, method_name)
+      @target = target
+      @method_name = method_name
+
+      Hardmock.track_replaced_method self
+    end
+  end
+
+  class StubbedMethod < ReplacedMethod #:nodoc:#
+    def invoke(args)
+      raise @raises if @raises
+      @return_value
+    end
+
+    def returns(stubbed_return)
+      @return_value = stubbed_return
+    end
+
+    def raises(err)
+      err = RuntimeError.new(err) unless err.kind_of?(Exception)
+      @raises = err
+    end
+  end
+
+  class ::Object
+    def stubs!(method_name)
+      method_name = method_name.to_s
+      already_stubbed = Hardmock.has_replaced_method?(self, method_name)
+
+      stubbed_method = Hardmock::StubbedMethod.new(self, method_name)
+
+
+      unless _is_mock? or already_stubbed
+        if methods.include?(method_name.to_s)
+          hm_meta_eval do 
+            alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
+          end
+        end
+      end
+
+      hm_meta_def method_name do |*args|
+        stubbed_method.invoke(args)
+      end
+
+      stubbed_method
+    end
+
+    def expects!(method_name, *args, &block)
+      if self._is_mock?
+        raise Hardmock::StubbingError, "Cannot use 'expects!(:#{method_name})' on a Mock object; try 'expects' instead"
+      end
+
+      method_name = method_name.to_s
+
+      @_my_mock = Mock.new(_my_name, $main_mock_control) if @_my_mock.nil?
+
+      unless Hardmock.has_replaced_method?(self, method_name)
+        # Track the method as replaced
+        Hardmock::ReplacedMethod.new(self, method_name)
+
+        # Preserver original implementation of the method by aliasing it away
+        if methods.include?(method_name)
+          hm_meta_eval do 
+            alias_method "_hardmock_original_#{method_name}".to_sym, method_name.to_sym
+          end
+        end
+
+        # Re-define the method to utilize our patron mock instance.
+        # (This global-temp-var thing is hokey but I was having difficulty generating 
+        # code for the meta class.)
+        begin
+          $method_text_temp = %{
+            def #{method_name}(*args,&block)
+              @_my_mock.__send__(:#{method_name}, *args, &block)
+            end
+          }
+          class << self
+            eval $method_text_temp
+          end
+        ensure
+          $method_text_temp = nil
+        end
+      end
+
+      return @_my_mock.expects(method_name, *args, &block)
+    end
+      
+    def _is_mock?
+      self.kind_of?(Mock)
+    end
+
+    def _my_name
+      self.kind_of?(Class) ? self.name : self.class.name
+    end
+
+    def _clear_mock
+      @_my_mock = nil
+    end
+
+  end
+
+  class ::NilClass
+    # Use this only if you really mean it
+    alias_method :intentionally_stubs!, :stubs!
+    
+    # Use this only if you really mean it
+    alias_method :intentionally_expects!, :expects!
+
+    # Overridden to protect against accidental nil reference self delusion 
+    def stubs!(mname)
+      raise StubbingError, "Cannot stub #{mname} method on nil.  (If you really mean to, try 'intentionally_stubs!')"
+    end
+
+    # Overridden to protect against accidental nil reference self delusion 
+    def expects!(mname, *args)
+      raise StubbingError, "Cannot mock #{mname} method on nil.  (If you really mean to, try 'intentionally_expects!')"
+    end
+  end
+
+  class << self
+    def track_replaced_method(replaced_method)
+      all_replaced_methods << replaced_method
+    end
+
+    def all_replaced_methods
+      $all_replaced_methods ||= []
+    end
+
+    def has_replaced_method?(obj, method_name)
+      hits = all_replaced_methods.select do |replaced|
+        (replaced.target.object_id == obj.object_id) and (replaced.method_name.to_s == method_name.to_s)
+      end
+      return !hits.empty?
+    end
+
+    def restore_all_replaced_methods
+      all_replaced_methods.each do |replaced|
+        unless replaced.target._is_mock?
+          backed_up = "_hardmock_original_#{replaced.method_name}"
+          if replaced.target.methods.include?(backed_up)
+            replaced.target.hm_meta_eval do
+              alias_method replaced.method_name.to_sym, backed_up.to_sym 
+            end
+          end
+          replaced.target._clear_mock
+        end
+      end
+      all_replaced_methods.clear
+    end
+  end
+
+end
+

data/vendor/hardmock/lib/hardmock/trapper.rb

@@ -1,31 +1,31 @@
-require 'test/unit/assertions'
-require 'hardmock/errors'
-
-module Hardmock
-  class Trapper #:nodoc:
-    include Hardmock::MethodCleanout
-
-    def initialize(mock,mock_control,expectation_builder)
-      @mock = mock
-      @mock_control = mock_control
-      @expectation_builder = expectation_builder
-    end
-
-    def method_missing(mname, *args)
-      if block_given?
-        raise ExpectationError.new("Don't pass blocks when using 'trap' (setting exepectations for '#{mname}')")
-      end
-      
-      the_block = lambda { |target_block| target_block }
-      expectation = @expectation_builder.build_expectation(
-        :mock => @mock, 
-        :method => mname, 
-        :arguments => args, 
-        :suppress_arguments_to_block => true,
-        :block => the_block)
-
-      @mock_control.add_expectation expectation
-      expectation
-    end
-  end
-end
+require 'test/unit/assertions'
+require 'hardmock/errors'
+
+module Hardmock
+  class Trapper #:nodoc:
+    include Hardmock::MethodCleanout
+
+    def initialize(mock,mock_control,expectation_builder)
+      @mock = mock
+      @mock_control = mock_control
+      @expectation_builder = expectation_builder
+    end
+
+    def method_missing(mname, *args)
+      if block_given?
+        raise ExpectationError.new("Don't pass blocks when using 'trap' (setting exepectations for '#{mname}')")
+      end
+      
+      the_block = lambda { |target_block| target_block }
+      expectation = @expectation_builder.build_expectation(
+        :mock => @mock, 
+        :method => mname, 
+        :arguments => args, 
+        :suppress_arguments_to_block => true,
+        :block => the_block)
+
+      @mock_control.add_expectation expectation
+      expectation
+    end
+  end
+end

data/vendor/hardmock/lib/hardmock/utils.rb

@@ -1,9 +1,9 @@
-
-module Hardmock
-  module Utils #:nodoc:
-    def format_method_call_string(mock,mname,args)
-      arg_string = args.map { |a| a.inspect }.join(', ')
-      call_text = "#{mock._name}.#{mname}(#{arg_string})"
-    end
-  end
-end
+
+module Hardmock
+  module Utils #:nodoc:
+    def format_method_call_string(mock,mname,args)
+      arg_string = args.map { |a| a.inspect }.join(', ')
+      call_text = "#{mock._name}.#{mname}(#{arg_string})"
+    end
+  end
+end

data/vendor/hardmock/lib/hardmock.rb

@@ -1,86 +1,86 @@
-require 'hardmock/method_cleanout'
-require 'hardmock/mock'
-require 'hardmock/mock_control'
-require 'hardmock/utils'
-require 'hardmock/errors'
-require 'hardmock/trapper'
-require 'hardmock/expector'
-require 'hardmock/expectation'
-require 'hardmock/expectation_builder'
-require 'hardmock/stubbing'
-
-module Hardmock
-
-  # Create one or more new Mock instances in your test suite. 
-  # Once created, the Mocks are accessible as instance variables in your test.
-  # Newly built Mocks are added to the full set of Mocks for this test, which will
-  # be verified when you call verify_mocks.
-  #
-  #   create_mocks :donkey, :cat # Your test now has @donkey and @cat
-  #   create_mock  :dog          # Test now has @donkey, @cat and @dog
-  #   
-  # The first call returned a hash { :donkey => @donkey, :cat => @cat }
-  # and the second call returned { :dog => @dog }
-  #
-  # For more info on how to use your mocks, see Mock and Expectation
-  #
-  def create_mocks(*mock_names)
-    prepare_hardmock_control unless @main_mock_control
-
-    mocks = {}
-    mock_names.each do |mock_name|
-      raise ArgumentError, "'nil' is not a valid name for a mock" if mock_name.nil?
-      mock_name = mock_name.to_s
-      mock_object = Mock.new(mock_name, @main_mock_control)
-      mocks[mock_name.to_sym] = mock_object
-      self.instance_variable_set "@#{mock_name}", mock_object
-    end
-    @all_mocks ||= {}
-    @all_mocks.merge! mocks
-
-    return mocks.clone
-  end
-
-  def prepare_hardmock_control
-    if @main_mock_control.nil?
-      @main_mock_control = MockControl.new
-      $main_mock_control = @main_mock_control
-    else
-      raise "@main_mock_control is already setup for this test!"
-    end
-  end
-
-  alias :create_mock :create_mocks
-
-  # Ensures that all expectations have been met.  If not, VerifyException is
-  # raised.
-  #
-  # <b>You normally won't need to call this yourself.</b> Within Test::Unit::TestCase, this will be done automatically at teardown time.
-  #
-  # * +force+ -- if +false+, and a VerifyError or ExpectationError has already occurred, this method will not raise.  This is to help you suppress repeated errors when if you're calling #verify_mocks in the teardown method of your test suite.  BE WARNED - only use this if you're sure you aren't obscuring useful information.  Eg, if your code handles exceptions internally, and an ExpectationError gets gobbled up by your +rescue+ block, the cause of failure for your test may be hidden from you.  For this reason, #verify_mocks defaults to force=true as of Hardmock 1.0.1
-  def verify_mocks(force=true)
-    return unless @main_mock_control
-    return if @main_mock_control.disappointed? and !force
-    @main_mock_control.verify
-  ensure
-    @main_mock_control.clear_expectations if @main_mock_control
-    $main_mock_control = nil
-    reset_stubs
-  end
-  
-  alias :verify_hardmocks :verify_mocks
-
-  # Purge the main MockControl of all expectations, restore all concrete stubbed/mocked methods
-  def clear_expectations
-    @main_mock_control.clear_expectations if @main_mock_control
-    reset_stubs
-    $main_mock_control = nil
-  end
-
-  def reset_stubs
-    Hardmock.restore_all_replaced_methods
-  end
-
-end
-
-require 'extend_test_unit'
+require 'hardmock/method_cleanout'
+require 'hardmock/mock'
+require 'hardmock/mock_control'
+require 'hardmock/utils'
+require 'hardmock/errors'
+require 'hardmock/trapper'
+require 'hardmock/expector'
+require 'hardmock/expectation'
+require 'hardmock/expectation_builder'
+require 'hardmock/stubbing'
+
+module Hardmock
+
+  # Create one or more new Mock instances in your test suite. 
+  # Once created, the Mocks are accessible as instance variables in your test.
+  # Newly built Mocks are added to the full set of Mocks for this test, which will
+  # be verified when you call verify_mocks.
+  #
+  #   create_mocks :donkey, :cat # Your test now has @donkey and @cat
+  #   create_mock  :dog          # Test now has @donkey, @cat and @dog
+  #   
+  # The first call returned a hash { :donkey => @donkey, :cat => @cat }
+  # and the second call returned { :dog => @dog }
+  #
+  # For more info on how to use your mocks, see Mock and Expectation
+  #
+  def create_mocks(*mock_names)
+    prepare_hardmock_control unless @main_mock_control
+
+    mocks = {}
+    mock_names.each do |mock_name|
+      raise ArgumentError, "'nil' is not a valid name for a mock" if mock_name.nil?
+      mock_name = mock_name.to_s
+      mock_object = Mock.new(mock_name, @main_mock_control)
+      mocks[mock_name.to_sym] = mock_object
+      self.instance_variable_set "@#{mock_name}", mock_object
+    end
+    @all_mocks ||= {}
+    @all_mocks.merge! mocks
+
+    return mocks.clone
+  end
+
+  def prepare_hardmock_control
+    if @main_mock_control.nil?
+      @main_mock_control = MockControl.new
+      $main_mock_control = @main_mock_control
+    else
+      raise "@main_mock_control is already setup for this test!"
+    end
+  end
+
+  alias :create_mock :create_mocks
+
+  # Ensures that all expectations have been met.  If not, VerifyException is
+  # raised.
+  #
+  # <b>You normally won't need to call this yourself.</b> Within Test::Unit::TestCase, this will be done automatically at teardown time.
+  #
+  # * +force+ -- if +false+, and a VerifyError or ExpectationError has already occurred, this method will not raise.  This is to help you suppress repeated errors when if you're calling #verify_mocks in the teardown method of your test suite.  BE WARNED - only use this if you're sure you aren't obscuring useful information.  Eg, if your code handles exceptions internally, and an ExpectationError gets gobbled up by your +rescue+ block, the cause of failure for your test may be hidden from you.  For this reason, #verify_mocks defaults to force=true as of Hardmock 1.0.1
+  def verify_mocks(force=true)
+    return unless @main_mock_control
+    return if @main_mock_control.disappointed? and !force
+    @main_mock_control.verify
+  ensure
+    @main_mock_control.clear_expectations if @main_mock_control
+    $main_mock_control = nil
+    reset_stubs
+  end
+  
+  alias :verify_hardmocks :verify_mocks
+
+  # Purge the main MockControl of all expectations, restore all concrete stubbed/mocked methods
+  def clear_expectations
+    @main_mock_control.clear_expectations if @main_mock_control
+    reset_stubs
+    $main_mock_control = nil
+  end
+
+  def reset_stubs
+    Hardmock.restore_all_replaced_methods
+  end
+
+end
+
+require 'extend_test_unit'