ceedling 0.28.3 → 0.29.0

data/vendor/hardmock/lib/hardmock/mock_control.rb

@@ -1,53 +1,53 @@
-require 'hardmock/utils'
-
-module Hardmock
-  class MockControl #:nodoc:
-    include Utils
-    attr_accessor :name
-
-    def initialize
-      clear_expectations
-    end
-
-    def happy?
-      @expectations.empty?
-    end
-
-    def disappointed?
-      @disappointed
-    end
-
-    def add_expectation(expectation)
-#      puts "MockControl #{self.object_id.to_s(16)} adding expectation: #{expectation}"
-      @expectations << expectation
-    end
-
-    def apply_method_call(mock,mname,args,block)
-      # Are we even expecting any sort of call?
-      if happy?
-        @disappointed = true
-        raise ExpectationError.new("Surprise call to #{format_method_call_string(mock,mname,args)}")
-      end
-
-      begin
-        @expectations.shift.apply_method_call(mock,mname,args,block)
-      rescue Exception => ouch
-        @disappointed = true
-        raise ouch
-      end
-    end
-
-    def verify
-#      puts "MockControl #{self.object_id.to_s(16)} verify: happy? #{happy?}"
-      @disappointed = !happy?
-      raise VerifyError.new("Unmet expectations", @expectations) unless happy?
-    end
-
-    def clear_expectations
-      @expectations = []
-      @disappointed = false
-    end
-
-  end
-
-end
+require 'hardmock/utils'
+
+module Hardmock
+  class MockControl #:nodoc:
+    include Utils
+    attr_accessor :name
+
+    def initialize
+      clear_expectations
+    end
+
+    def happy?
+      @expectations.empty?
+    end
+
+    def disappointed?
+      @disappointed
+    end
+
+    def add_expectation(expectation)
+#      puts "MockControl #{self.object_id.to_s(16)} adding expectation: #{expectation}"
+      @expectations << expectation
+    end
+
+    def apply_method_call(mock,mname,args,block)
+      # Are we even expecting any sort of call?
+      if happy?
+        @disappointed = true
+        raise ExpectationError.new("Surprise call to #{format_method_call_string(mock,mname,args)}")
+      end
+
+      begin
+        @expectations.shift.apply_method_call(mock,mname,args,block)
+      rescue Exception => ouch
+        @disappointed = true
+        raise ouch
+      end
+    end
+
+    def verify
+#      puts "MockControl #{self.object_id.to_s(16)} verify: happy? #{happy?}"
+      @disappointed = !happy?
+      raise VerifyError.new("Unmet expectations", @expectations) unless happy?
+    end
+
+    def clear_expectations
+      @expectations = []
+      @disappointed = false
+    end
+
+  end
+
+end

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
+