mocha 1.1.0 → 2.1.0

data/lib/mocha/inspect.rb

@@ -1,67 +1,59 @@
 require 'date'
 
 module Mocha
-
-  module ObjectMethods
-    def mocha_inspect
-      address = self.__id__ * 2
-      address += 0x100000000 if address < 0
-      inspect =~ /#</ ? "#<#{self.class}:0x#{'%x' % address}>" : inspect
+  module Inspect
+    module ObjectMethods
+      def mocha_inspect
+        address = __id__ * 2
+        address += 0x100000000 if address < 0
+        inspect =~ /#</ ? "#<#{self.class}:0x#{Kernel.format('%<address>x', address: address)}>" : inspect
+      end
     end
-  end
 
-  module StringMethods
-    def mocha_inspect
-      inspect.gsub(/\"/, "'")
+    module ArrayMethods
+      def mocha_inspect(wrapped = true)
+        unwrapped = collect(&:mocha_inspect).join(', ')
+        wrapped ? "[#{unwrapped}]" : unwrapped
+      end
     end
-  end
 
-  module ArrayMethods
-    def mocha_inspect
-      "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
+    module HashMethods
+      def mocha_inspect
+        unwrapped = collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')
+        Hash.ruby2_keywords_hash?(self) ? unwrapped : "{#{unwrapped}}"
+      end
     end
-  end
 
-  module HashMethods
-    def mocha_inspect
-      "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+    module TimeMethods
+      def mocha_inspect
+        "#{inspect} (#{to_f} secs)"
+      end
     end
-  end
 
-  module TimeMethods
-    def mocha_inspect
-      "#{inspect} (#{to_f} secs)"
+    module DateMethods
+      def mocha_inspect
+        to_s
+      end
     end
   end
-
-  module DateMethods
-    def mocha_inspect
-      to_s
-    end
-  end
-
 end
 
 class Object
-  include Mocha::ObjectMethods
-end
-
-class String
-  include Mocha::StringMethods
+  include Mocha::Inspect::ObjectMethods
 end
 
 class Array
-  include Mocha::ArrayMethods
+  include Mocha::Inspect::ArrayMethods
 end
 
 class Hash
-  include Mocha::HashMethods
+  include Mocha::Inspect::HashMethods
 end
 
 class Time
-  include Mocha::TimeMethods
+  include Mocha::Inspect::TimeMethods
 end
 
 class Date
-  include Mocha::DateMethods
+  include Mocha::Inspect::DateMethods
 end

data/lib/mocha/instance_method.rb

@@ -1,16 +1,19 @@
-require 'mocha/class_method'
+require 'mocha/stubbed_method'
 
 module Mocha
+  class InstanceMethod < StubbedMethod
+    private
 
-  class InstanceMethod < ClassMethod
+    def mock_owner
+      stubbee
+    end
 
-    def method_exists?(method)
-      return true if stubbee.public_methods(false).include?(method)
-      return true if stubbee.protected_methods(false).include?(method)
-      return true if stubbee.private_methods(false).include?(method)
-      return false
+    def stubbee_method(method_name)
+      stubbee._method(method_name)
     end
 
+    def original_method_owner
+      stubbee.singleton_class
+    end
   end
-
 end

data/lib/mocha/integration/mini_test/adapter.rb

@@ -5,7 +5,6 @@ require 'mocha/expectation_error_factory'
 module Mocha
   module Integration
     module MiniTest
-
       # Integrates Mocha into recent versions of MiniTest.
       #
       # See the source code for an example of how to integrate Mocha into a test library.
@@ -19,12 +18,12 @@ module Mocha
 
         # @private
         def self.description
-          "adapter for MiniTest gem >= v3.3.0"
+          'adapter for MiniTest gem >= v3.3.0'
         end
 
         # @private
-        def self.included(mod)
-          Mocha::ExpectationErrorFactory.exception_class = ::MiniTest::Assertion
+        def self.included(_mod)
+          Mocha::ExpectationErrorFactory.exception_class = ::Minitest::Assertion
         end
 
         # @private
@@ -51,4 +50,3 @@ module Mocha
     end
   end
 end
-

data/lib/mocha/integration/mini_test/exception_translation.rb

@@ -4,7 +4,7 @@ module Mocha
   module Integration
     module MiniTest
       def self.translate(exception)
-        return exception unless exception.kind_of?(::Mocha::ExpectationError)
+        return exception unless exception.is_a?(::Mocha::ExpectationError)
         translated_exception = ::MiniTest::Assertion.new(exception.message)
         translated_exception.set_backtrace(exception.backtrace)
         translated_exception

data/lib/mocha/integration/mini_test.rb

@@ -1,47 +1,26 @@
 require 'mocha/debug'
-
 require 'mocha/detection/mini_test'
-
-require 'mocha/integration/mini_test/nothing'
-require 'mocha/integration/mini_test/version_13'
-require 'mocha/integration/mini_test/version_140'
-require 'mocha/integration/mini_test/version_141'
-require 'mocha/integration/mini_test/version_142_to_172'
-require 'mocha/integration/mini_test/version_200'
-require 'mocha/integration/mini_test/version_201_to_222'
-require 'mocha/integration/mini_test/version_230_to_2101'
-require 'mocha/integration/mini_test/version_2110_to_2111'
-require 'mocha/integration/mini_test/version_2112_to_320'
 require 'mocha/integration/mini_test/adapter'
 
 module Mocha
   module Integration
     module MiniTest
       def self.activate
-        return false unless Detection::MiniTest.testcase
-        mini_test_version = Gem::Version.new(Detection::MiniTest.version)
+        target = Detection::MiniTest.testcase
+        return false unless target
 
+        mini_test_version = Gem::Version.new(Detection::MiniTest.version)
         Debug.puts "Detected MiniTest version: #{mini_test_version}"
 
-        integration_module = [
-          MiniTest::Adapter,
-          MiniTest::Version2112To320,
-          MiniTest::Version2110To2111,
-          MiniTest::Version230To2101,
-          MiniTest::Version201To222,
-          MiniTest::Version200,
-          MiniTest::Version142To172,
-          MiniTest::Version141,
-          MiniTest::Version140,
-          MiniTest::Version13,
-          MiniTest::Nothing
-        ].detect { |m| m.applicable_to?(mini_test_version) }
+        unless MiniTest::Adapter.applicable_to?(mini_test_version)
+          raise 'Versions of minitest earlier than v3.3.0 are not supported.'
+        end
 
-        target = Detection::MiniTest.testcase
-        unless target < integration_module
-          Debug.puts "Applying #{integration_module.description}"
-          target.send(:include, integration_module)
+        unless target < MiniTest::Adapter
+          Debug.puts "Applying #{MiniTest::Adapter.description}"
+          target.send(:include, MiniTest::Adapter)
         end
+
         true
       end
     end

data/lib/mocha/integration/monkey_patcher.rb

@@ -4,13 +4,19 @@ module Mocha
   module Integration
     module MonkeyPatcher
       def self.apply(mod, run_method_patch)
-        unless mod < Mocha::API
+        if mod < Mocha::API
+          Debug.puts "Mocha::API already included in #{mod}"
+        else
           mod.send(:include, Mocha::API)
         end
-        unless mod.method_defined?(:run_before_mocha)
+        if mod.method_defined?(:run_before_mocha)
+          Debug.puts "#{mod}#run_before_mocha method already defined"
+        elsif mod.method_defined?(:run)
           mod.send(:alias_method, :run_before_mocha, :run)
           mod.send(:remove_method, :run)
           mod.send(:include, run_method_patch)
+        else
+          raise "Unable to monkey-patch #{mod}, because it does not define a `#run` method"
         end
       end
     end

data/lib/mocha/integration/test_unit/adapter.rb

@@ -5,7 +5,6 @@ require 'mocha/expectation_error'
 module Mocha
   module Integration
     module TestUnit
-
       # Integrates Mocha into recent versions of Test::Unit.
       #
       # See the source code for an example of how to integrate Mocha into a test library.
@@ -13,36 +12,36 @@ module Mocha
         include Mocha::API
 
         # @private
-        def self.applicable_to?(test_unit_version, ruby_version = nil)
+        def self.applicable_to?(test_unit_version)
           Gem::Requirement.new('>= 2.5.1').satisfied_by?(test_unit_version)
         end
 
         # @private
         def self.description
-          "adapter for Test::Unit gem >= v2.5.1"
+          'adapter for Test::Unit gem >= v2.5.1'
         end
 
         # @private
         def self.included(mod)
-          mod.setup :mocha_setup, :before => :prepend
+          mod.setup :mocha_setup, before: :prepend
 
           mod.exception_handler(:handle_mocha_expectation_error)
 
-          mod.cleanup :after => :append do
+          mod.cleanup after: :append do
             assertion_counter = Integration::AssertionCounter.new(self)
             mocha_verify(assertion_counter)
           end
 
-          mod.teardown :mocha_teardown, :after => :append
+          mod.teardown :mocha_teardown, after: :append
         end
 
         private
 
         # @private
-        def handle_mocha_expectation_error(e)
-          return false unless e.is_a?(Mocha::ExpectationError)
+        def handle_mocha_expectation_error(exception)
+          return false unless exception.is_a?(Mocha::ExpectationError)
           problem_occurred
-          add_failure(e.message, e.backtrace)
+          add_failure(exception.message, exception.backtrace)
           true
         end
       end

data/lib/mocha/integration/test_unit.rb

@@ -1,42 +1,26 @@
 require 'mocha/debug'
-
 require 'mocha/detection/test_unit'
-
-require 'mocha/integration/test_unit/nothing'
-require 'mocha/integration/test_unit/ruby_version_185_and_below'
-require 'mocha/integration/test_unit/ruby_version_186_and_above'
-require 'mocha/integration/test_unit/gem_version_200'
-require 'mocha/integration/test_unit/gem_version_201_to_202'
-require 'mocha/integration/test_unit/gem_version_203_to_220'
-require 'mocha/integration/test_unit/gem_version_230_to_250'
 require 'mocha/integration/test_unit/adapter'
 
 module Mocha
   module Integration
     module TestUnit
       def self.activate
-        return false unless Detection::TestUnit.testcase
-        test_unit_version = Gem::Version.new(Detection::TestUnit.version)
-        ruby_version = Gem::Version.new(RUBY_VERSION.dup)
+        target = Detection::TestUnit.testcase
+        return false unless target
 
-        Debug.puts "Detected Ruby version: #{ruby_version}"
+        test_unit_version = Gem::Version.new(Detection::TestUnit.version)
         Debug.puts "Detected Test::Unit version: #{test_unit_version}"
 
-        integration_module = [
-          TestUnit::Adapter,
-          TestUnit::GemVersion230To250,
-          TestUnit::GemVersion203To220,
-          TestUnit::GemVersion201To202,
-          TestUnit::GemVersion200,
-          TestUnit::RubyVersion186AndAbove,
-          TestUnit::RubyVersion185AndBelow,
-          TestUnit::Nothing
-        ].detect { |m| m.applicable_to?(test_unit_version, ruby_version) }
+        unless TestUnit::Adapter.applicable_to?(test_unit_version)
+          raise 'Versions of test-unit earlier than v2.5.1 are not supported.'
+        end
 
-        unless ::Test::Unit::TestCase < integration_module
-          Debug.puts "Applying #{integration_module.description}"
-          ::Test::Unit::TestCase.send(:include, integration_module)
+        unless target < TestUnit::Adapter
+          Debug.puts "Applying #{TestUnit::Adapter.description}"
+          target.send(:include, TestUnit::Adapter)
         end
+
         true
       end
     end

data/lib/mocha/invocation.rb

@@ -0,0 +1,73 @@
+require 'mocha/parameters_matcher'
+require 'mocha/raised_exception'
+require 'mocha/return_values'
+require 'mocha/thrown_object'
+require 'mocha/yield_parameters'
+
+module Mocha
+  class Invocation
+    attr_reader :method_name, :block
+
+    def initialize(mock, method_name, arguments = [], block = nil)
+      @mock = mock
+      @method_name = method_name
+      @arguments = arguments
+      @block = block
+      @yields = []
+      @result = nil
+    end
+
+    def call(yield_parameters = YieldParameters.new, return_values = ReturnValues.new)
+      yield_parameters.next_invocation.each do |yield_args|
+        @yields << ParametersMatcher.new(yield_args)
+        raise LocalJumpError unless @block
+        @block.call(*yield_args)
+      end
+      return_values.next(self)
+    end
+
+    def returned(value)
+      @result = value
+    end
+
+    def raised(exception)
+      @result = RaisedException.new(exception)
+    end
+
+    def threw(tag, value)
+      @result = ThrownObject.new(tag, value)
+    end
+
+    def arguments
+      @arguments.dup
+    end
+
+    def call_description
+      description = "#{@mock.mocha_inspect}.#{@method_name}#{argument_description}"
+      description << ' { ... }' unless @block.nil?
+      description
+    end
+
+    def short_call_description
+      "#{@method_name}(#{@arguments.join(', ')})"
+    end
+
+    def result_description
+      desc = "# => #{@result.mocha_inspect}"
+      desc << " after yielding #{@yields.map(&:mocha_inspect).join(', then ')}" if @yields.any?
+      desc
+    end
+
+    def full_description
+      "\n  - #{call_description} #{result_description}"
+    end
+
+    private
+
+    def argument_description
+      signature = arguments.mocha_inspect
+      signature = signature.gsub(/^\[|\]$/, '')
+      "(#{signature})"
+    end
+  end
+end

data/lib/mocha/is_a.rb

@@ -1,9 +1,7 @@
 class Object
-
   # :stopdoc:
 
   alias_method :__is_a__, :is_a?
 
   # :startdoc:
-
 end

data/lib/mocha/logger.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class Logger
-
     def initialize(io)
       @io = io
     end
@@ -9,7 +7,5 @@ module Mocha
     def warn(message)
       @io.puts "WARNING: #{message}"
     end
-
   end
-
 end

data/lib/mocha/macos_version.rb

@@ -0,0 +1,5 @@
+module Mocha
+  MACOS = /darwin/.match(RUBY_PLATFORM)
+  MACOS_VERSION = MACOS && /darwin(\d+)/.match(RUBY_PLATFORM)[1].to_i
+  MACOS_MOJAVE_VERSION = 18
+end

data/lib/mocha/method_matcher.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class MethodMatcher
-
     attr_reader :expected_method_name
 
     def initialize(expected_method_name)
@@ -13,9 +11,7 @@ module Mocha
     end
 
     def mocha_inspect
-      "#{@expected_method_name}"
+      @expected_method_name.to_s
     end
-
   end
-
 end

data/lib/mocha/minitest.rb

@@ -0,0 +1,6 @@
+require 'mocha/ruby_version'
+require 'mocha/integration/mini_test'
+
+unless Mocha::Integration::MiniTest.activate
+  raise "MiniTest must be loaded *before* `require 'mocha/minitest'`."
+end