mocha 1.5.0 → 1.10.0

data/lib/mocha/mockery.rb

@@ -11,11 +11,8 @@ require 'mocha/not_initialized_error'
 require 'mocha/expectation_error_factory'
 
 module Mocha
-
   class Mockery
-
     class Null < self
-
       def add_mock(*)
         raise_not_initialized_error
       end
@@ -34,11 +31,9 @@ module Mocha
         message = 'Mocha methods cannot be used outside the context of a test'
         raise NotInitializedError.new(message, caller)
       end
-
     end
 
     class << self
-
       def instance
         instances.last || Null.new
       end
@@ -65,23 +60,22 @@ module Mocha
       def instances
         @instances ||= []
       end
-
     end
 
-    def named_mock(name, &block)
-      add_mock(Mock.new(self, Name.new(name), &block))
+    def named_mock(name)
+      add_mock(Mock.new(self, Name.new(name)))
     end
 
-    def unnamed_mock(&block)
-      add_mock(Mock.new(self, &block))
+    def unnamed_mock
+      add_mock(Mock.new(self))
     end
 
-    def mock_impersonating(object, &block)
-      add_mock(Mock.new(self, ImpersonatingName.new(object), ObjectReceiver.new(object), &block))
+    def mock_impersonating(object)
+      add_mock(Mock.new(self, ImpersonatingName.new(object), ObjectReceiver.new(object)))
     end
 
-    def mock_impersonating_any_instance_of(klass, &block)
-      add_mock(Mock.new(self, ImpersonatingAnyInstanceName.new(klass), AnyInstanceReceiver.new(klass), &block))
+    def mock_impersonating_any_instance_of(klass)
+      add_mock(Mock.new(self, ImpersonatingAnyInstanceName.new(klass), AnyInstanceReceiver.new(klass)))
     end
 
     def new_state_machine(name)
@@ -91,18 +85,17 @@ module Mocha
     def verify(assertion_counter = nil)
       unless mocks.all? { |mock| mock.__verified__?(assertion_counter) }
         message = "not all expectations were satisfied\n#{mocha_inspect}"
-        if unsatisfied_expectations.empty?
-          backtrace = caller
-        else
-          backtrace = unsatisfied_expectations[0].backtrace
-        end
+        backtrace = if unsatisfied_expectations.empty?
+                      caller
+                    else
+                      unsatisfied_expectations[0].backtrace
+                    end
         raise ExpectationErrorFactory.build(message, backtrace)
       end
       expectations.each do |e|
-        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
-          unless e.used?
-            on_stubbing_method_unnecessarily(e)
-          end
+        unless Mocha.configuration.stubbing_method_unnecessarily == :allow
+          next if e.used?
+          on_stubbing_method_unnecessarily(e)
         end
       end
     end
@@ -125,78 +118,28 @@ module Mocha
     end
 
     def mocha_inspect
-      message = ""
-      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless unsatisfied_expectations.empty?
-      message << "satisfied expectations:\n- #{satisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless satisfied_expectations.empty?
-      message << "states:\n- #{state_machines.map { |sm| sm.mocha_inspect }.join("\n- ")}" unless state_machines.empty?
+      message = ''
+      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" unless unsatisfied_expectations.empty?
+      message << "satisfied expectations:\n- #{satisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" unless satisfied_expectations.empty?
+      message << "states:\n- #{state_machines.map(&:mocha_inspect).join("\n- ")}" unless state_machines.empty?
       message
     end
 
     def on_stubbing(object, method)
       method = PRE_RUBY_V19 ? method.to_s : method.to_sym
-      unless Mocha::Configuration.allow?(:stubbing_non_existent_method)
-        unless object.method_exists?(method, include_public_methods = true)
-          on_stubbing_non_existent_method(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_non_public_method)
-        if object.method_exists?(method, include_public_methods = false)
-          on_stubbing_non_public_method(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_method_on_nil)
-        if object.nil?
-          on_stubbing_method_on_nil(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_method_on_non_mock_object)
-        on_stubbing_method_on_non_mock_object(object, method)
-      end
-    end
-
-    def on_stubbing_non_existent_method(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_non_existent_method)
-        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
-        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{method}"
-      end
-    end
-
-    def on_stubbing_non_public_method(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_non_public_method)
-        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_non_public_method)
-        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{method}"
-      end
-    end
-
-    def on_stubbing_method_on_nil(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_method_on_nil)
-        raise StubbingError.new("stubbing method on nil: #{object.mocha_inspect}.#{method}", caller)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_method_on_nil)
-        logger.warn "stubbing method on nil: #{object.mocha_inspect}.#{method}"
-      end
-    end
-
-    def on_stubbing_method_on_non_mock_object(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_method_on_non_mock_object)
-        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{method}", caller)
+      method_signature = "#{object.mocha_inspect}.#{method}"
+      check(:stubbing_non_existent_method, 'non-existent method', method_signature) do
+        !(object.stubba_class.__method_exists__?(method, true) || object.respond_to?(method.to_sym))
       end
-      if Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
-        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{method}"
+      check(:stubbing_non_public_method, 'non-public method', method_signature) do
+        object.stubba_class.__method_exists__?(method, false)
       end
+      check(:stubbing_method_on_nil, 'method on nil', method_signature) { object.nil? }
+      check(:stubbing_method_on_non_mock_object, 'method on non-mock object', method_signature)
     end
 
     def on_stubbing_method_unnecessarily(expectation)
-      if Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
-        raise StubbingError.new("stubbing method unnecessarily: #{expectation.method_signature}", expectation.backtrace)
-      end
-      if Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
-        logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
-      end
+      check(:stubbing_method_unnecessarily, 'method unnecessarily', expectation.method_signature, expectation.backtrace)
     end
 
     attr_writer :logger
@@ -205,19 +148,29 @@ module Mocha
       @logger ||= Logger.new($stderr)
     end
 
-
     private
 
+    def check(action, description, method_signature, backtrace = caller)
+      return if block_given? && !yield
+      message = "stubbing #{description}: #{method_signature}"
+      case Mocha.configuration.send(action)
+      when :warn
+        logger.warn(message)
+      when :prevent
+        raise StubbingError.new(message, backtrace)
+      end
+    end
+
     def expectations
       mocks.map { |mock| mock.__expectations__.to_a }.flatten
     end
 
     def unsatisfied_expectations
-      expectations.reject { |e| e.verified? }
+      expectations.reject(&:verified?)
     end
 
     def satisfied_expectations
-      expectations.select { |e| e.verified? }
+      expectations.select(&:verified?)
     end
 
     def add_mock(mock)
@@ -235,7 +188,5 @@ module Mocha
       @mocks = nil
       @state_machines = nil
     end
-
   end
-
 end

data/lib/mocha/multiple_yields.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class MultipleYields
-
     attr_reader :parameter_groups
 
     def initialize(*parameter_groups)
@@ -13,8 +11,5 @@ module Mocha
         yield(parameter_group)
       end
     end
-
   end
-
 end
-

data/lib/mocha/names.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class ImpersonatingName
-
     def initialize(object)
       @object = object
     end
@@ -9,11 +7,9 @@ module Mocha
     def mocha_inspect
       @object.mocha_inspect
     end
-
   end
 
   class ImpersonatingAnyInstanceName
-
     def initialize(klass)
       @klass = klass
     end
@@ -21,23 +17,19 @@ module Mocha
     def mocha_inspect
       "#<AnyInstance:#{@klass.mocha_inspect}>"
     end
-
   end
 
   class Name
-
     def initialize(name)
-      @name = name
+      @name = name.to_s
     end
 
     def mocha_inspect
       "#<Mock:#{@name}>"
     end
-
   end
 
   class DefaultName
-
     def initialize(mock)
       @mock = mock
     end
@@ -45,9 +37,7 @@ module Mocha
     def mocha_inspect
       address = @mock.__id__ * 2
       address += 0x100000000 if address < 0
-      "#<Mock:0x#{'%x' % address}>"
+      "#<Mock:0x#{format('%x', address)}>"
     end
-
   end
-
 end

data/lib/mocha/no_yields.rb

@@ -1,11 +1,5 @@
 module Mocha
-
   class NoYields
-
-    def each
-    end
-
+    def each; end
   end
-
 end
-

data/lib/mocha/not_initialized_error.rb

@@ -1,9 +1,7 @@
 require 'mocha/error_with_filtered_backtrace'
 
 module Mocha
-
   # Exception raised when Mocha has not been initialized, e.g. outside the
   # context of a test.
   class NotInitializedError < ErrorWithFilteredBacktrace; end
-
 end

data/lib/mocha/object_methods.rb

@@ -4,18 +4,20 @@ require 'mocha/argument_iterator'
 require 'mocha/expectation_error_factory'
 
 module Mocha
-
   # Methods added to all objects to allow mocking and stubbing on real (i.e. non-mock) objects.
   #
   # Both {#expects} and {#stubs} return an {Expectation} which can be further modified by methods on {Expectation}.
   module ObjectMethods
-
     # @private
     alias_method :_method, :method
 
     # @private
-    def mocha
-      @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+    def mocha(instantiate = true)
+      if instantiate
+        @mocha ||= Mocha::Mockery.instance.mock_impersonating(self)
+      else
+        defined?(@mocha) ? @mocha : nil
+      end
     end
 
     # @private
@@ -33,17 +35,22 @@ module Mocha
       self
     end
 
+    # @private
+    def stubba_class
+      singleton_class
+    end
+
     # Adds an expectation that the specified method must be called exactly once with any parameters.
     #
     # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
     #
-    # @param [Symbol,String] method_name name of expected method
-    # @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {#expects} were called multiple times.
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
     #
     # @overload def expects(method_name)
+    #   @param [Symbol,String] method_name name of expected method
     # @overload def expects(expected_methods_vs_return_values)
-    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
-    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {#expects} were called multiple times.
     #
     # @example Setting up an expectation on a non-mock object.
     #   product = Product.new
@@ -71,14 +78,14 @@ module Mocha
       expectation = nil
       mockery = Mocha::Mockery.instance
       iterator = ArgumentIterator.new(expected_methods_vs_return_values)
-      iterator.each { |*args|
+      iterator.each do |*args|
         method_name = args.shift
         mockery.on_stubbing(self, method_name)
         method = stubba_method.new(stubba_object, method_name)
         mockery.stubba.stub(method)
         expectation = mocha.expects(method_name, caller)
-        expectation.returns(args.shift) if args.length > 0
-      }
+        expectation.returns(args.shift) unless args.empty?
+      end
       expectation
     end
 
@@ -86,13 +93,13 @@ module Mocha
     #
     # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
     #
-    # @param [Symbol,String] method_name name of stubbed method
-    # @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {#stubs} were called multiple times.
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
     #
     # @overload def stubs(method_name)
+    #   @param [Symbol,String] method_name name of stubbed method
     # @overload def stubs(stubbed_methods_vs_return_values)
-    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
-    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {#stubs} were called multiple times.
     #
     # @example Setting up a stubbed methods on a non-mock object.
     #   product = Product.new
@@ -117,14 +124,14 @@ module Mocha
       expectation = nil
       mockery = Mocha::Mockery.instance
       iterator = ArgumentIterator.new(stubbed_methods_vs_return_values)
-      iterator.each { |*args|
+      iterator.each do |*args|
         method_name = args.shift
         mockery.on_stubbing(self, method_name)
         method = stubba_method.new(stubba_object, method_name)
         mockery.stubba.stub(method)
         expectation = mocha.stubs(method_name, caller)
-        expectation.returns(args.shift) if args.length > 0
-      }
+        expectation.returns(args.shift) unless args.empty?
+      end
       expectation
     end
 
@@ -158,18 +165,5 @@ module Mocha
         mockery.stubba.unstub(method)
       end
     end
-
-    # @private
-    def method_exists?(method, include_public_methods = true)
-      if include_public_methods
-        return true if public_methods(include_superclass_methods = true).include?(method)
-        return true if respond_to?(method.to_sym)
-      end
-      return true if protected_methods(include_superclass_methods = true).include?(method)
-      return true if private_methods(include_superclass_methods = true).include?(method)
-      return false
-    end
-
   end
-
 end

data/lib/mocha/parameter_matchers.rb

@@ -1,11 +1,9 @@
 module Mocha
-
   # Used as parameters for {Expectation#with} to restrict the parameter values which will match the expectation. Can be nested.
   module ParameterMatchers; end
-
 end
 
-require 'mocha/parameter_matchers/object'
+require 'mocha/parameter_matchers/instance_methods'
 
 require 'mocha/parameter_matchers/all_of'
 require 'mocha/parameter_matchers/any_of'

data/lib/mocha/parameter_matchers/all_of.rb

@@ -1,12 +1,10 @@
 require 'mocha/parameter_matchers/base'
 
 module Mocha
-
   module ParameterMatchers
-
     # Matches if all +matchers+ match.
     #
-    # @param [*Array<Base>] parameter_matchers parameter matchers.
+    # @param [*Array<Base>] matchers parameter matchers.
     # @return [AllOf] parameter matcher.
     #
     # @see Expectation#with
@@ -28,7 +26,6 @@ module Mocha
 
     # Parameter matcher which combines a number of other matchers using a logical AND.
     class AllOf < Base
-
       # @private
       def initialize(*matchers)
         @matchers = matchers
@@ -42,11 +39,8 @@ module Mocha
 
       # @private
       def mocha_inspect
-        "all_of(#{@matchers.map { |matcher| matcher.mocha_inspect }.join(", ") })"
+        "all_of(#{@matchers.map(&:mocha_inspect).join(', ')})"
       end
-
     end
-
   end
-
 end