muack 0.5.0

data/Rakefile

@@ -0,0 +1,18 @@
+
+require "#{dir = File.dirname(__FILE__)}/task/gemgem"
+Gemgem.dir = dir
+
+($LOAD_PATH << File.expand_path("#{Gemgem.dir}/lib")).uniq!
+
+desc 'Generate gemspec'
+task 'gem:spec' do
+  Gemgem.spec = Gemgem.create do |s|
+    require 'muack/version'
+    s.name    = 'muack'
+    s.version = Muack::VERSION
+
+    %w[].each{ |g| s.add_runtime_dependency(g) }
+  end
+
+  Gemgem.write
+end

data/lib/muack.rb

@@ -0,0 +1,77 @@
+
+require 'muack/mock'
+require 'muack/stub'
+require 'muack/proxy'
+
+require 'muack/satisfy'
+require 'muack/session'
+
+require 'muack/any_instance_of'
+
+module Muack
+  def self.verify
+    session.verify
+  ensure
+    reset
+  end
+
+  def self.session
+    @session ||= Muack::Session.new
+  end
+
+  def self.reset
+    @session && @session.reset
+    @session = nil
+  end
+
+  module API
+    module_function
+    def mock obj=Object.new
+      ret = Muack.session["mk #{obj.__id__}"] ||= Muack::Mock.new(obj)
+      if block_given? then yield(ret) else ret end
+    end
+
+    def stub obj=Object.new
+      ret = Muack.session["sb #{obj.__id__}"] ||= Muack::Stub.new(obj)
+      if block_given? then yield(ret) else ret end
+    end
+
+    def mock_proxy obj=Object.new
+      ret = Muack.session["mp #{obj.__id__}"] ||= Muack::MockProxy.new(obj)
+      if block_given? then yield(ret) else ret end
+    end
+
+    def stub_proxy obj=Object.new
+      ret = Muack.session["sp #{obj.__id__}"] ||= Muack::StubProxy.new(obj)
+      if block_given? then yield(ret) else ret end
+    end
+
+    def any_instance_of klass
+      yield Muack::AnyInstanceOf.new(klass)
+    end
+
+    def is_a klass
+      Muack::IsA.new(klass)
+    end
+
+    def anything
+      Muack::Anything.new
+    end
+
+    def match regexp
+      Muack::Match.new(regexp)
+    end
+
+    def hash_including hash
+      Muack::HashIncluding.new(hash)
+    end
+
+    def within range_or_array
+      Muack::Within.new(range_or_array)
+    end
+
+    def satisfy &block
+      Muack::Satisfy.new(block)
+    end
+  end
+end

data/lib/muack/any_instance_of.rb

@@ -0,0 +1,4 @@
+
+module Muack
+  AnyInstanceOf = Class.new(Struct.new(:singleton_class))
+end

data/lib/muack/definition.rb

@@ -0,0 +1,5 @@
+
+module Muack
+  Definition  = Class.new(Struct.new(:msg, :args, :block, :original_method))
+  WithAnyArgs = Object.new
+end

data/lib/muack/failure.rb

@@ -0,0 +1,38 @@
+
+module Muack
+  class Failure < Exception
+    attr_reader :expected
+    def build_expected obj, expected_defis
+      @expected = expected_defis.uniq{ |d| [d.msg, d.args] }.map{ |defi|
+                    "#{obj.inspect}.#{defi.msg}(" \
+                    "#{defi.args.map(&:inspect).join(', ')})"
+                  }.join("\n      or: ")
+    end
+  end
+
+  class Unexpected < Failure
+    attr_reader :was
+    def initialize obj, expected_defis, msg, args
+      @was = "#{obj.inspect}.#{msg}(" \
+             "#{args.map(&:inspect).join(', ')})"
+      if expected_defis.empty?
+        super("\nExpected: #{@was}\n          was not called.")
+      else
+        build_expected(obj, expected_defis)
+        super("\nExpected: #{expected}\n but was: #{was}")
+      end
+    end
+  end
+
+  class Expected < Failure
+    attr_reader :expected_times, :actual_times
+    def initialize obj, defi, expected_times, actual_times
+      build_expected(obj, [defi])
+      @expected_times = expected_times
+      @actual_times   = actual_times
+
+      super("\nExpected: #{expected}\n  called #{expected_times} times\n" \
+            " but was #{actual_times} times.")
+    end
+  end
+end

data/lib/muack/mock.rb

@@ -0,0 +1,167 @@
+
+require 'muack/definition'
+require 'muack/modifier'
+require 'muack/failure'
+
+module Muack
+  class Mock < BasicObject
+    attr_reader :object
+    def initialize object
+      @object = object
+      @__mock_ignore = []
+      [:__mock_defis=, :__mock_disps=].each do |m|
+        __send__(m, ::Hash.new{ |h, k| h[k] = [] })
+      end
+    end
+
+    # Public API: Bacon needs this, or we often ended up with stack overflow
+    def inspect
+      "#<#{class << self; self; end.superclass} object=#{object.inspect}>"
+    end
+
+    # Public API: Define mocked method
+    def method_missing msg, *args, &block
+      defi = Definition.new(msg, args, block)
+      __mock_inject_method(defi) if __mock_pure?(defi)
+      __mock_defis_push(defi)
+      Modifier.new(self, defi)
+    end
+
+    # used for Muack::Modifier#times
+    def __mock_defis_push defi
+      __mock_defis[defi.msg] << defi
+    end
+
+    # used for Muack::Modifier#times
+    def __mock_defis_pop defi
+      __mock_defis[defi.msg].pop
+    end
+
+    # used for Muack::Modifier#times
+    def __mock_ignore defi
+      @__mock_ignore << defi
+    end
+
+    # used for mocked object to dispatch mocked method
+    def __mock_dispatch msg, actual_args, actual_block
+      if defi = __mock_defis[msg].shift
+        __mock_disps_push(defi)
+        if __mock_check_args(defi.args, actual_args)
+          __mock_block_call(defi, actual_args, actual_block)
+        else
+          Mock.__send__(:raise, # Wrong argument
+            Unexpected.new(object, [defi], msg, actual_args))
+        end
+      else
+        defis = __mock_disps[msg]
+        if expected_defi = defis.find{ |d| d.args == actual_args }
+          Mock.__send__(:raise, # Too many times
+            Expected.new(object, expected_defi, defis.size, defis.size+1))
+        else
+          Mock.__send__(:raise, # Wrong argument
+            Unexpected.new(object, defis, msg, actual_args))
+        end
+      end
+    end
+
+    # used for Muack::Session#verify
+    def __mock_verify
+      __mock_defis.values.all?(&:empty?) || begin
+        msg, defis_with_same_msg = __mock_defis.find{ |_, v| v.size > 0 }
+        args, defis = defis_with_same_msg.group_by(&:args).first
+        dsize = __mock_disps[msg].select{ |d| d.args == args }.size
+        Mock.__send__(:raise,   # Too little times
+          Expected.new(object, defis.first, defis.size + dsize, dsize))
+      end
+    end
+
+    # used for Muack::Session#reset
+    def __mock_reset
+      [__mock_defis.values, __mock_disps.values, @__mock_ignore].
+      flatten.compact.each do |defi|
+        object.singleton_class.module_eval do
+          methods = instance_methods(false)
+          if methods.include?(defi.msg) # removed mocked method
+            remove_method(defi.msg)     # could be removed by other defi
+          end
+          if methods.include?(defi.original_method) # restore original method
+            alias_method defi.msg, defi.original_method
+            remove_method defi.original_method
+          end
+        end
+      end
+    end
+
+    protected # get warnings for private attributes
+    attr_accessor :__mock_defis, :__mock_disps
+
+    private
+    def __mock_pure? defi
+      __mock_defis[defi.msg].empty? && __mock_disps[defi.msg].empty?
+    end
+
+    def __mock_inject_method defi
+      target = object.singleton_class
+      Mock.store_original_method(target, defi)
+       __mock_inject_mock_method(target, defi)
+    end
+
+    def self.store_original_method klass, defi
+      return unless klass.instance_methods(false).include?(defi.msg)
+      # store original method
+      original_method = find_new_name(klass, defi.msg)
+      klass.__send__(:alias_method, original_method, defi.msg)
+      defi.original_method = original_method
+    end
+
+    def self.find_new_name klass, message, level=0
+      raise "Cannot find a suitable method name, tried #{level+1} times." if
+        level >= 9
+
+      new_name = "__muack_mock_#{level}_#{message}".to_sym
+      if klass.instance_methods(false).include?(new_name)
+        find_new_name(klass, message, level+1)
+      else
+        new_name
+      end
+    end
+
+    def __mock_inject_mock_method target, defi
+      mock = self # remember the context
+      target.__send__(:define_method, defi.msg){|*actual_args, &actual_block|
+        mock.__mock_dispatch(defi.msg, actual_args, actual_block)
+      }
+    end
+
+    def __mock_block_call defi, actual_args, actual_block
+      if block = defi.block
+        arity = block.arity
+        if arity < 0
+          block.call(*actual_args             , &actual_block)
+        else
+          block.call(*actual_args.first(arity), &actual_block)
+        end
+      end
+    end
+
+    def __mock_check_args expected_args, actual_args
+      if expected_args == [WithAnyArgs]
+        true
+      elsif expected_args.none?{ |arg| arg.kind_of?(Satisfy) }
+        expected_args == actual_args
+
+      elsif expected_args.size == actual_args.size
+        expected_args.zip(actual_args).all?{ |(e, a)|
+          if e.kind_of?(Satisfy) then e.match(a) else e == a end
+        }
+      else
+        false
+      end
+    end
+
+    # used for Muack::Mock#__mock_dispatch
+    def __mock_disps_push defi
+      __mock_disps[defi.msg] << defi
+    end
+  end
+end

data/lib/muack/modifier.rb

@@ -0,0 +1,29 @@
+
+require 'muack/definition'
+
+module Muack
+  class Modifier < Struct.new(:mock, :defi)
+    # Public API
+    def with_any_args
+      defi.args = [WithAnyArgs]
+      self
+    end
+
+    # Public API
+    def times number
+      if number >= 1
+        (number - 1).times{ mock.__mock_defis_push(defi) }
+      elsif number == 0
+        mock.__mock_ignore(mock.__mock_defis_pop(defi))
+      else
+        raise "What would you expect from calling a method #{number} times?"
+      end
+      self
+    end
+
+    # Public API
+    def object
+      mock.object
+    end
+  end
+end

data/lib/muack/proxy.rb

@@ -0,0 +1,39 @@
+
+require 'muack/mock'
+require 'muack/stub'
+
+module Muack
+  module Proxy
+    def __mock_block_call defi, actual_args, actual_block
+      # handle block call in injected method, since we need to call origin
+      defi # but we still want to know which defi gets dispatched!
+    end
+
+    def __mock_inject_mock_method target, defi
+      mock = self # remember the context
+      target.__send__(:define_method, defi.msg){|*actual_args, &actual_block|
+        d = mock.__mock_dispatch(defi.msg, actual_args, actual_block)
+
+        ret = if d.original_method
+                __send__(d.original_method, *actual_args, &actual_block)
+              else
+                super(*actual_args, &actual_block)
+              end
+
+        if d.block
+          d.block.call(ret)
+        else
+          ret
+        end
+      }
+    end
+  end
+
+  class MockProxy < Mock
+    include Proxy
+  end
+
+  class StubProxy < Stub
+    include Proxy
+  end
+end

data/lib/muack/satisfy.rb

@@ -0,0 +1,54 @@
+
+module Muack
+  class Satisfy < Struct.new(:block, :api_args)
+    def match actual_arg
+      !!block.call(actual_arg)
+    end
+
+    def to_s
+      "Muack::API.#{api_name}(#{api_args.map(&:inspect).join(', ')})"
+    end
+    alias_method :inspect, :to_s
+
+    def api_name
+      self.class.name[/::(\w+)$/, 1].
+        gsub(/([A-Z][a-z]*)+?(?=[A-Z][a-z]*)/, '\\1_').downcase
+    end
+
+    def api_args
+      super || [block]
+    end
+  end
+
+  class IsA < Satisfy
+    def initialize klass
+      super lambda{ |actual_arg| actual_arg.kind_of?(klass) }, [klass]
+    end
+  end
+
+  class Anything < Satisfy
+    def initialize
+      super lambda{ |_| true }, []
+    end
+  end
+
+  class Match < Satisfy
+    def initialize regexp
+      super lambda{ |actual_arg| regexp.match(actual_arg) }, [regexp]
+    end
+  end
+
+  class HashIncluding < Satisfy
+    def initialize hash
+      super lambda{ |actual_arg|
+        actual_arg.values_at(*hash.keys) == hash.values }, [hash]
+    end
+  end
+
+  class Within < Satisfy
+    def initialize range_or_array
+      super lambda{ |actual_arg| range_or_array.include?(actual_arg) },
+            [range_or_array]
+    end
+  end
+end

data/lib/muack/session.rb

@@ -0,0 +1,12 @@
+
+module Muack
+  class Session < Hash
+    def verify
+      each_value.all?(&:__mock_verify)
+    end
+
+    def reset
+      each_value(&:__mock_reset)
+    end
+  end
+end