class Minitest::Mock

def __call name, data # :nodoc:
  case data
  when Hash then
    "#{name}(#{data[:args].inspect[1..-2]}) => #{data[:retval].inspect}"
  else
    data.map { |d| __call name, d }.join ", "
  end
end

def expect name, retval, args = [], &blk
  name = name.to_sym
  if block_given?
    raise ArgumentError, "args ignored when block given" unless args.empty?
    @expected_calls[name] << { :retval => retval, :block => blk }
  else
    raise ArgumentError, "args must be an array" unless Array === args
    @expected_calls[name] << { :retval => retval, :args => args }
  end
  self
end

def initialize delegator = nil # :nodoc:
  @delegator = delegator
  @expected_calls = Hash.new { |calls, name| calls[name] = [] }
  @actual_calls   = Hash.new { |calls, name| calls[name] = [] }
end

def method_missing sym, *args, &block # :nodoc:
  unless @expected_calls.key?(sym) then
    if @delegator && @delegator.respond_to?(sym)
      return @delegator.public_send(sym, *args, &block)
    else
      raise NoMethodError, "unmocked method %p, expected one of %p" %
        [sym, @expected_calls.keys.sort_by(&:to_s)]
    end
  end
  index = @actual_calls[sym].length
  expected_call = @expected_calls[sym][index]
  unless expected_call then
    raise MockExpectationError, "No more expects available for %p: %p" %
      [sym, args]
  end
  expected_args, retval, val_block =
    expected_call.values_at(:args, :retval, :block)
  if val_block then
    # keep "verify" happy
    @actual_calls[sym] << expected_call
    raise MockExpectationError, "mocked method %p failed block w/ %p" %
      [sym, args] unless val_block.call(*args, &block)
    return retval
  end
  if expected_args.size != args.size then
    raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
      [sym, expected_args.size, args.size]
  end
  zipped_args = expected_args.zip(args)
  fully_matched = zipped_args.all? { |mod, a|
    mod === a or mod == a
  }
  unless fully_matched then
    raise MockExpectationError, "mocked method %p called with unexpected arguments %p" %
      [sym, args]
  end
  @actual_calls[sym] << {
    :retval => retval,
    :args => zipped_args.map! { |mod, a| mod === a ? mod : a },
  }
  retval
end

def respond_to? sym, include_private = false # :nodoc:
  return true if @expected_calls.key? sym.to_sym
  return true if @delegator && @delegator.respond_to?(sym, include_private)
  __respond_to?(sym, include_private)
end

def verify
  @expected_calls.each do |name, expected|
    actual = @actual_calls.fetch(name, nil)
    raise MockExpectationError, "expected #{__call name, expected[0]}" unless actual
    raise MockExpectationError, "expected #{__call name, expected[actual.size]}, got [#{__call name, actual}]" if
      actual.size < expected.size
  end
  true
end