mocha 1.1.0 → 1.13.0

data/lib/mocha/cardinality.rb

@@ -1,95 +1,106 @@
 module Mocha
-
   class Cardinality
-
     INFINITY = 1 / 0.0
 
-    class << self
+    def initialize(required = 0, maximum = INFINITY)
+      update(required, maximum)
+      @invocations = []
+    end
 
-      def exactly(count)
-        new(count, count)
-      end
+    def exactly(count)
+      update(count, count)
+    end
 
-      def at_least(count)
-        new(count, INFINITY)
-      end
+    def at_least(count)
+      update(count, INFINITY)
+    end
 
-      def at_most(count)
-        new(0, count)
-      end
+    def at_most(count)
+      update(0, count)
+    end
 
-      def times(range_or_count)
-        case range_or_count
-          when Range then new(range_or_count.first, range_or_count.last)
-          else new(range_or_count, range_or_count)
-        end
+    def times(range_or_count)
+      case range_or_count
+      when Range then update(range_or_count.first, range_or_count.last)
+      else update(range_or_count, range_or_count)
       end
-
     end
 
-    def initialize(required, maximum)
-      @required, @maximum = required, maximum
+    def <<(invocation)
+      @invocations << invocation
     end
 
-    def invocations_allowed?(invocation_count)
-      invocation_count < maximum
+    def invocations_allowed?
+      @invocations.size < maximum
     end
 
-    def satisfied?(invocations_so_far)
-      invocations_so_far >= required
+    def satisfied?
+      @invocations.size >= required
     end
 
     def needs_verifying?
       !allowed_any_number_of_times?
     end
 
-    def verified?(invocation_count)
-      (invocation_count >= required) && (invocation_count <= maximum)
+    def verified?
+      (@invocations.size >= required) && (@invocations.size <= maximum)
     end
 
     def allowed_any_number_of_times?
-      required == 0 && infinite?(maximum)
+      required.zero? && infinite?(maximum)
     end
 
-    def used?(invocation_count)
-      (invocation_count > 0) || (maximum == 0)
+    def used?
+      @invocations.any? || maximum.zero?
     end
 
-    def mocha_inspect
+    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+    def anticipated_times
       if allowed_any_number_of_times?
-        "allowed any number of times"
+        'allowed any number of times'
+      elsif required.zero? && maximum.zero?
+        "expected #{count(maximum)}"
+      elsif required == maximum
+        "expected exactly #{count(required)}"
+      elsif infinite?(maximum)
+        "expected at least #{count(required)}"
+      elsif required.zero?
+        "expected at most #{count(maximum)}"
       else
-        if required == 0 && maximum == 0
-          "expected never"
-        elsif required == maximum
-          "expected exactly #{times(required)}"
-        elsif infinite?(maximum)
-          "expected at least #{times(required)}"
-        elsif required == 0
-          "expected at most #{times(maximum)}"
-        else
-          "expected between #{required} and #{times(maximum)}"
-        end
+        "expected between #{required} and #{count(maximum)}"
       end
     end
+    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+
+    def invoked_times
+      "invoked #{count(@invocations.size)}"
+    end
+
+    def actual_invocations
+      @invocations.map(&:full_description).join
+    end
 
     protected
 
     attr_reader :required, :maximum
 
-    def times(number)
+    def count(number)
       case number
-        when 0 then "no times"
-        when 1 then "once"
-        when 2 then "twice"
-        else "#{number} times"
+      when 0 then 'never'
+      when 1 then 'once'
+      when 2 then 'twice'
+      else "#{number} times"
       end
     end
 
+    def update(required, maximum)
+      @required = required
+      @maximum = maximum
+      self
+    end
+
     def infinite?(number)
       number.respond_to?(:infinite?) && number.infinite?
     end
-
   end
-
 end

data/lib/mocha/central.rb

@@ -1,6 +1,19 @@
 module Mocha
-
   class Central
+    class Null < self
+      def initialize(&block)
+        super
+        @raise_not_initialized_error = block
+      end
+
+      def stub(*)
+        @raise_not_initialized_error.call
+      end
+
+      def unstub(*)
+        @raise_not_initialized_error.call
+      end
+    end
 
     attr_accessor :stubba_methods
 
@@ -9,25 +22,21 @@ module Mocha
     end
 
     def stub(method)
-      unless stubba_methods.detect { |m| m.matches?(method) }
-        method.stub
-        stubba_methods.push(method)
-      end
+      return if stubba_methods.detect { |m| m.matches?(method) }
+      method.stub
+      stubba_methods.push(method)
     end
 
     def unstub(method)
-      if existing = stubba_methods.detect { |m| m.matches?(method) }
-        existing.unstub
-        stubba_methods.delete(existing)
-      end
+      return unless (existing = stubba_methods.detect { |m| m.matches?(method) })
+      existing.unstub
+      stubba_methods.delete(existing)
     end
 
     def unstub_all
-      while stubba_methods.any? do
+      while stubba_methods.any?
         unstub(stubba_methods.first)
       end
     end
-
   end
-
 end

data/lib/mocha/change_state_side_effect.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class ChangeStateSideEffect
-
     def initialize(state)
       @state = state
     end
@@ -13,7 +11,5 @@ module Mocha
     def mocha_inspect
       "then #{@state.mocha_inspect}"
     end
-
   end
-
 end

data/lib/mocha/class_methods.rb

@@ -1,45 +1,36 @@
 require 'mocha/mockery'
-require 'mocha/class_method'
 require 'mocha/any_instance_method'
 
 module Mocha
-
   # Methods added to all classes to allow mocking and stubbing on real (i.e. non-mock) objects.
   module ClassMethods
-
-    # @private
-    def stubba_method
-      Mocha::ClassMethod
-    end
-
     # @private
     class AnyInstance
-
       def initialize(klass)
         @stubba_object = klass
       end
 
-      def mocha
-        @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+      def mocha(instantiate = true)
+        if instantiate
+          @mocha ||= Mocha::Mockery.instance.mock_impersonating_any_instance_of(@stubba_object)
+        else
+          defined?(@mocha) ? @mocha : nil
+        end
       end
 
       def stubba_method
         Mocha::AnyInstanceMethod
       end
 
-      def stubba_object
+      def stubba_class
         @stubba_object
       end
 
-      def method_exists?(method, include_public_methods = true)
-        if include_public_methods
-          return true if @stubba_object.public_instance_methods(include_superclass_methods = true).include?(method)
-        end
-        return true if @stubba_object.protected_instance_methods(include_superclass_methods = true).include?(method)
-        return true if @stubba_object.private_instance_methods(include_superclass_methods = true).include?(method)
-        return false
+      def respond_to?(method)
+        @stubba_object.allocate.respond_to?(method.to_sym)
       end
 
+      attr_reader :stubba_object
     end
 
     # @return [Mock] a mock object which will detect calls to any instance of this class.
@@ -58,6 +49,14 @@ module Mocha
       @any_instance ||= AnyInstance.new(self)
     end
 
+    # @private
+    # rubocop:disable Metrics/CyclomaticComplexity
+    def __method_visibility__(method, include_public_methods = true)
+      (include_public_methods && public_method_defined?(method) && :public) ||
+        (protected_method_defined?(method) && :protected) ||
+        (private_method_defined?(method) && :private)
+    end
+    # rubocop:enable Metrics/CyclomaticComplexity
+    alias_method :__method_exists__?, :__method_visibility__
   end
-
 end