mocha 0.10.5 → 1.13.0

data/lib/mocha/parameters_matcher.rb

@@ -2,36 +2,33 @@ require 'mocha/inspect'
 require 'mocha/parameter_matchers'
 
 module Mocha
-  
   class ParametersMatcher
-    
     def initialize(expected_parameters = [ParameterMatchers::AnyParameters.new], &matching_block)
-      @expected_parameters, @matching_block = expected_parameters, matching_block
+      @expected_parameters = expected_parameters
+      @matching_block = matching_block
     end
-    
+
     def match?(actual_parameters = [])
       if @matching_block
-        return @matching_block.call(*actual_parameters)
+        @matching_block.call(*actual_parameters)
       else
-        return parameters_match?(actual_parameters)
+        parameters_match?(actual_parameters)
       end
     end
-    
+
     def parameters_match?(actual_parameters)
-      matchers.all? { |matcher| matcher.matches?(actual_parameters) } && (actual_parameters.length == 0)
+      matchers.all? { |matcher| matcher.matches?(actual_parameters) } && actual_parameters.empty?
     end
-    
+
     def mocha_inspect
       signature = matchers.mocha_inspect
       signature = signature.gsub(/^\[|\]$/, '')
       signature = signature.gsub(/^\{|\}$/, '') if matchers.length == 1
       "(#{signature})"
     end
-    
+
     def matchers
-      @expected_parameters.map { |parameter| parameter.to_matcher }
+      @expected_parameters.map(&:to_matcher)
     end
-    
   end
-
-end
+end

data/lib/mocha/raised_exception.rb

@@ -0,0 +1,11 @@
+module Mocha
+  class RaisedException
+    def initialize(exception)
+      @exception = exception
+    end
+
+    def mocha_inspect
+      "raised #{@exception}"
+    end
+  end
+end

data/lib/mocha/receivers.rb

@@ -0,0 +1,45 @@
+module Mocha
+  class ObjectReceiver
+    def initialize(object)
+      @object = object
+    end
+
+    def mocks
+      object = @object
+      mocks = []
+      while object
+        mocha = object.mocha(false)
+        mocks << mocha if mocha
+        object = object.is_a?(Class) ? object.superclass : nil
+      end
+      mocks
+    end
+  end
+
+  class AnyInstanceReceiver
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def mocks
+      klass = @klass
+      mocks = []
+      while klass
+        mocha = klass.any_instance.mocha(false)
+        mocks << mocha if mocha
+        klass = klass.superclass
+      end
+      mocks
+    end
+  end
+
+  class DefaultReceiver
+    def initialize(mock)
+      @mock = mock
+    end
+
+    def mocks
+      [@mock]
+    end
+  end
+end

data/lib/mocha/return_values.rb

@@ -1,31 +1,27 @@
 require 'mocha/single_return_value'
 
-module Mocha # :nodoc:
-  
-  class ReturnValues # :nodoc:
-    
+module Mocha
+  class ReturnValues
     def self.build(*values)
       new(*values.map { |value| SingleReturnValue.new(value) })
     end
-    
+
     attr_accessor :values
-    
+
     def initialize(*values)
       @values = values
     end
-    
-    def next
+
+    def next(invocation)
       case @values.length
-        when 0 then nil
-        when 1 then @values.first.evaluate
-        else @values.shift.evaluate
+      when 0 then nil
+      when 1 then @values.first.evaluate(invocation)
+      else @values.shift.evaluate(invocation)
       end
     end
-    
+
     def +(other)
       self.class.new(*(@values + other.values))
     end
-    
   end
-  
-end
+end

data/lib/mocha/ruby_version.rb

@@ -0,0 +1,4 @@
+module Mocha
+  PRE_RUBY_V19 = Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('1.9')
+  RUBY_V2_PLUS = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2')
+end

data/lib/mocha/sequence.rb

@@ -1,42 +1,46 @@
-module Mocha # :nodoc:
-  
+module Mocha
+  # Used to constrain the order in which expectations can occur.
+  #
+  # @see API#sequence
+  # @see Expectation#in_sequence
   class Sequence
-    
+    # @private
     class InSequenceOrderingConstraint
-      
       def initialize(sequence, index)
-        @sequence, @index = sequence, index
+        @sequence = sequence
+        @index = index
       end
-      
+
       def allows_invocation_now?
         @sequence.satisfied_to_index?(@index)
       end
-      
+
       def mocha_inspect
         "in sequence #{@sequence.mocha_inspect}"
       end
-      
     end
-    
+
+    # @private
     def initialize(name)
       @name = name
       @expectations = []
     end
-    
+
+    # @private
     def constrain_as_next_in_sequence(expectation)
       index = @expectations.length
       @expectations << expectation
       expectation.add_ordering_constraint(InSequenceOrderingConstraint.new(self, index))
     end
-    
+
+    # @private
     def satisfied_to_index?(index)
-      @expectations[0...index].all? { |expectation| expectation.satisfied? }
+      @expectations[0...index].all?(&:satisfied?)
     end
-    
+
+    # @private
     def mocha_inspect
-      "#{@name.mocha_inspect}"
+      @name.mocha_inspect.to_s
     end
-    
   end
-  
-end
+end

data/lib/mocha/setup.rb

@@ -0,0 +1,14 @@
+require 'mocha/integration'
+require 'mocha/deprecation'
+
+Mocha::Deprecation.warning(
+  "Require 'mocha/test_unit', 'mocha/minitest' or 'mocha/api' instead of 'mocha/setup'."
+)
+
+module Mocha
+  def self.activate
+    Integration.activate
+  end
+end
+
+Mocha.activate

data/lib/mocha/single_return_value.rb

@@ -1,17 +1,14 @@
 require 'mocha/is_a'
 
-module Mocha # :nodoc:
-  
-  class SingleReturnValue # :nodoc:
-    
+module Mocha
+  class SingleReturnValue
     def initialize(value)
       @value = value
     end
-    
-    def evaluate
+
+    def evaluate(invocation)
+      invocation.returned(@value)
       @value
     end
-    
   end
-  
 end

data/lib/mocha/singleton_class.rb

@@ -0,0 +1,9 @@
+if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('1.9.2')
+  unless Kernel.method_defined?(:singleton_class)
+    module Kernel
+      def singleton_class
+        class << self; self; end
+      end
+    end
+  end
+end

data/lib/mocha/state_machine.rb

@@ -1,91 +1,93 @@
-module Mocha # :nodoc:
-
+module Mocha
   # A state machine that is used to constrain the order of invocations.
-  # An invocation can be constrained to occur when a state is, or is_not, active.
+  # An invocation can be constrained to occur when a state {#is}, or {#is_not}, active.
   class StateMachine
-  
-    class State # :nodoc:
-    
-      def initialize(state_machine, state)
-        @state_machine, @state = state_machine, state
-      end
-    
-      def activate
-        @state_machine.current_state = @state
+    # Provides the ability to determine whether a {StateMachine} is in a specified state at some point in the future.
+    class StatePredicate
+      # @private
+      def initialize(state_machine, state, description, &active_check)
+        @state_machine = state_machine
+        @state = state
+        @description = description
+        @active_check = active_check
       end
-    
+
+      # @private
       def active?
-        @state_machine.current_state == @state
+        @active_check.call(@state_machine.current_state, @state)
       end
-    
+
+      # @private
       def mocha_inspect
-        "#{@state_machine.name} is #{@state.mocha_inspect}"
+        "#{@state_machine.name} #{@description} #{@state.mocha_inspect}"
       end
-    
     end
-    
-    class StatePredicate # :nodoc:
-      
-      def initialize(state_machine, state)
-        @state_machine, @state = state_machine, state
-      end
-    
-      def active?
-        @state_machine.current_state != @state
-      end
-    
-      def mocha_inspect
-        "#{@state_machine.name} is not #{@state.mocha_inspect}"
+
+    # Provides a mechanism to change the state of a {StateMachine} at some point in the future.
+    class State < StatePredicate
+      # @private
+      def activate
+        @state_machine.current_state = @state
       end
-      
     end
-    
-    attr_reader :name # :nodoc:
-    
-    attr_accessor :current_state # :nodoc:
-    
-    def initialize(name) # :nodoc:
+
+    # @private
+    attr_reader :name
+
+    # @private
+    attr_accessor :current_state
+
+    # @private
+    def initialize(name)
       @name = name
       @current_state = nil
     end
-    
-    # :call-seq: starts_as(initial_state) -> state_machine
+
+    # Put the {StateMachine} into the state specified by +initial_state_name+.
     #
-    # Put the +state_machine+ into the +initial_state+.
-    def starts_as(initial_state)
-      become(initial_state)
+    # @param [String] initial_state_name name of initial state
+    # @return [StateMachine] state machine, thereby allowing invocations of other {StateMachine} methods to be chained.
+    def starts_as(initial_state_name)
+      become(initial_state_name)
       self
     end
-  
-    # :call-seq: become(next_state)
+
+    # Put the {StateMachine} into the +next_state_name+.
     #
-    # Put the +state_machine+ into the +next_state+.
-    def become(next_state)
-      @current_state = next_state
+    # @param [String] next_state_name name of new state
+    def become(next_state_name)
+      @current_state = next_state_name
     end
-  
-    # :call-seq: is(state)
+
+    # Provides mechanisms to (a) determine whether the {StateMachine} is in a given state; or (b) to change the {StateMachine} into the given state.
     #
-    # Determines whether the +state_machine+ is in the specified +state+.
-    def is(state)
-      State.new(self, state)
+    # @param [String] state_name name of expected/desired state.
+    # @return [StatePredicate,State] (a) state predicate which, when queried, will indicate whether the {StateMachine} is in the given state; or (b) state which, when activated, will change the {StateMachine} into the given state.
+    #
+    # @overload def is(expected_state_name)
+    #   Provides a mechanism to determine whether the {StateMachine} is in the state specified by +expected_state_name+ at some point in the future
+    #   @param [String] expected_state_name name of expected state.
+    #   @return [StatePredicate] state predicate which, when queried, will indicate whether the {StateMachine} is in the state specified by +expected_state_name+
+    #
+    # @overload def is(desired_state_name)
+    #   Provides a mechanism to change the {StateMachine} into the state specified by +desired_state_name+ at some point in the future.
+    #   @param [String] desired_state_name name of desired new state.
+    #   @return [State] state which, when activated, will change the {StateMachine} into the state with the specified +desired_state_name+.
+    def is(state_name)
+      State.new(self, state_name, 'is') { |current, given| current == given }
     end
-  
-    # :call-seq: is_not(state)
+
+    # Provides a mechanism to determine whether the {StateMachine} is *not* in the state specified by +unexpected_state_name+ at some point in the future.
     #
-    # Determines whether the +state_machine+ is not in the specified +state+.
-    def is_not(state)
-      StatePredicate.new(self, state)
+    # @param [String] unexpected_state_name name of unexpected state.
+    # @return [StatePredicate] state predicate which, when queried, will indicate whether the {StateMachine} is *not* in the state specified by +unexpected_state_name+.
+    def is_not(unexpected_state_name) # rubocop:disable Naming/PredicateName
+      StatePredicate.new(self, unexpected_state_name, 'is not') { |current, given| current != given }
     end
-  
-    def mocha_inspect # :nodoc:
-      if @current_state
-        "#{@name} is #{@current_state.mocha_inspect}"
-      else
-        "#{@name} has no current state"
-      end
+
+    # @private
+    def mocha_inspect
+      %(#{@name} #{@current_state ? "is #{@current_state.mocha_inspect}" : 'has no current state'})
     end
-  
   end
-
-end
+end

data/lib/mocha/stubbed_method.rb

@@ -0,0 +1,125 @@
+require 'mocha/ruby_version'
+require 'mocha/singleton_class'
+
+module Mocha
+  class StubbedMethod
+    PrependedModule = Class.new(Module)
+
+    attr_reader :stubbee, :method_name
+
+    def initialize(stubbee, method_name)
+      @stubbee = stubbee
+      @original_method = nil
+      @original_visibility = nil
+      @method_name = PRE_RUBY_V19 ? method_name.to_s : method_name.to_sym
+    end
+
+    def stub
+      hide_original_method
+      define_new_method
+    end
+
+    def unstub
+      remove_new_method
+      restore_original_method
+      mock.unstub(method_name.to_sym)
+      return if mock.any_expectations?
+      reset_mocha
+    end
+
+    def mock
+      mock_owner.mocha
+    end
+
+    def reset_mocha
+      mock_owner.reset_mocha
+    end
+
+    def hide_original_method
+      return unless original_method_owner.__method_exists__?(method_name)
+      store_original_method_visibility
+      if use_prepended_module_for_stub_method?
+        use_prepended_module_for_stub_method
+      else
+        begin
+          store_original_method
+        # rubocop:disable Lint/HandleExceptions
+        rescue NameError
+          # deal with nasties like ActiveRecord::Associations::AssociationProxy
+        end
+        # rubocop:enable Lint/HandleExceptions
+        if stub_method_overwrites_original_method?
+          remove_original_method_from_stubbee
+        end
+      end
+    end
+
+    def define_new_method
+      self_in_scope = self
+      method_name_in_scope = method_name
+      stub_method_owner.send(:define_method, method_name) do |*args, &block|
+        self_in_scope.mock.method_missing(method_name_in_scope, *args, &block)
+      end
+      retain_original_visibility(stub_method_owner)
+    end
+
+    def remove_new_method
+      stub_method_owner.send(:remove_method, method_name)
+    end
+
+    def store_original_method
+      @original_method = stubbee_method(method_name)
+    end
+
+    def restore_original_method
+      return if use_prepended_module_for_stub_method?
+      if stub_method_overwrites_original_method?
+        original_method_owner.send(:define_method, method_name, method_body(@original_method))
+      end
+      retain_original_visibility(original_method_owner)
+    end
+
+    def matches?(other)
+      return false unless other.class == self.class
+      (stubbee.object_id == other.stubbee.object_id) && (method_name == other.method_name)
+    end
+
+    alias_method :==, :eql?
+
+    def to_s
+      "#{stubbee}.#{method_name}"
+    end
+
+    private
+
+    def retain_original_visibility(method_owner)
+      return unless @original_visibility
+      Module.instance_method(@original_visibility).bind(method_owner).call(method_name)
+    end
+
+    def store_original_method_visibility
+      @original_visibility = original_method_owner.__method_visibility__(method_name)
+    end
+
+    def stub_method_overwrites_original_method?
+      @original_method && @original_method.owner == original_method_owner
+    end
+
+    def remove_original_method_from_stubbee
+      original_method_owner.send(:remove_method, method_name)
+    end
+
+    def use_prepended_module_for_stub_method?
+      RUBY_V2_PLUS
+    end
+
+    def use_prepended_module_for_stub_method
+      @stub_method_owner = PrependedModule.new
+      original_method_owner.__send__ :prepend, @stub_method_owner
+    end
+
+    def stub_method_owner
+      @stub_method_owner ||= original_method_owner
+    end
+  end
+end

data/lib/mocha/stubbing_error.rb

@@ -1,16 +1,8 @@
-require 'mocha/backtrace_filter'
+require 'mocha/error_with_filtered_backtrace'
 
-module Mocha # :nodoc:
-  
-  # Exception raised when an action prevented by Configuration#prevent is attempted.
-  class StubbingError < StandardError
-
-    def initialize(message = nil, backtrace = []) # :nodoc:
-      super(message)
-      filter = BacktraceFilter.new
-      set_backtrace(filter.filtered(backtrace))
-    end
-
-  end
-  
+module Mocha
+  # Exception raised when stubbing a particular method is not allowed.
+  #
+  # @see Configuration.prevent
+  class StubbingError < ErrorWithFilteredBacktrace; end
 end

data/lib/mocha/test_unit.rb

@@ -0,0 +1,8 @@
+require 'mocha/integration/test_unit'
+require 'mocha/deprecation'
+
+unless Mocha::Integration::TestUnit.activate
+  Mocha::Deprecation.warning(
+    "Test::Unit must be loaded *before* `require 'mocha/test_unit'`."
+  )
+end

data/lib/mocha/thrower.rb

@@ -1,15 +1,13 @@
-module Mocha # :nodoc:
-
-  class Thrower # :nodoc:
-
+module Mocha
+  class Thrower
     def initialize(tag, object = nil)
-      @tag, @object = tag, object
+      @tag = tag
+      @object = object
     end
 
-    def evaluate
+    def evaluate(invocation)
+      invocation.threw(@tag, @object)
       throw @tag, @object
     end
-
   end
-
 end

data/lib/mocha/thrown_object.rb

@@ -0,0 +1,12 @@
+module Mocha
+  class ThrownObject
+    def initialize(tag, value = nil)
+      @tag = tag
+      @value = value
+    end
+
+    def mocha_inspect
+      "threw (#{@tag.mocha_inspect}, #{@value.mocha_inspect})"
+    end
+  end
+end

data/lib/mocha/version.rb

@@ -1,3 +1,3 @@
 module Mocha
-  VERSION = "0.10.5"
+  VERSION = '1.13.0'.freeze
 end

data/lib/mocha/yield_parameters.rb

@@ -1,31 +1,21 @@
-require 'mocha/no_yields'
-require 'mocha/single_yield'
-require 'mocha/multiple_yields'
-
-module Mocha # :nodoc:
-  
-  class YieldParameters # :nodoc:
-    
+module Mocha
+  class YieldParameters
     def initialize
       @parameter_groups = []
     end
-    
+
     def next_invocation
       case @parameter_groups.length
-        when 0 then NoYields.new
-        when 1 then @parameter_groups.first
-        else @parameter_groups.shift
+      when 0 then []
+      when 1 then @parameter_groups.first
+      else @parameter_groups.shift
       end
     end
-    
-    def add(*parameters)
-      @parameter_groups << SingleYield.new(*parameters)
-    end
-    
-    def multiple_add(*parameter_groups)
-      @parameter_groups << MultipleYields.new(*parameter_groups)
+
+    def add(*parameter_groups)
+      @parameter_groups << parameter_groups.map do |pg|
+        pg.is_a?(Array) ? pg : [pg]
+      end
     end
-    
   end
-  
-end
+end