class MiniTest::Mock

def call name, data
  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=[])
  raise ArgumentError, "args must be an array" unless Array === args
  @expected_calls[name] << { :retval => retval, :args => args }
  self
end

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

def method_missing(sym, *args) # :nodoc:
  unless @expected_calls.has_key?(sym) then
    raise NoMethodError, "unmocked method %p, expected one of %p" %
      [sym, @expected_calls.keys.sort_by(&:to_s)]
  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 = expected_call[:args], expected_call[:retval]
  if expected_args.size != args.size then
    raise ArgumentError, "mocked method %p expects %d arguments, got %d" %
      [sym, expected_args.size, args.size]
  end
  fully_matched = expected_args.zip(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 => expected_args.zip(args).map { |mod, a| mod === a ? mod : a }
  }
  retval
end

def respond_to?(sym) # :nodoc:
  return true if @expected_calls.has_key?(sym.to_sym)
  return __respond_to?(sym)
end

def verify
  @expected_calls.each do |name, calls|
    calls.each do |expected|
      msg1 = "expected #{call name, expected}"
      msg2 = "#{msg1}, got [#{call name, @actual_calls[name]}]"
      raise MockExpectationError, msg2 if
        @actual_calls.has_key? name and
        not @actual_calls[name].include?(expected)
      raise MockExpectationError, msg1 unless
        @actual_calls.has_key? name and @actual_calls[name].include?(expected)
    end
  end
  true
end