class RSpec::Mocks::BaseExpectation

def and_raise(exception=Exception)
  @exception_to_raise = exception
end

def and_return(*values, &return_block)
  Kernel::raise AmbiguousReturnError unless @method_block.nil?
  case values.size
    when 0 then value = nil
    when 1 then value = values[0]
  else
    value = values
    @consecutive = true
    @expected_received_count = values.size if !ignoring_args? &&
                                              @expected_received_count < values.size
  end
  @return_block = block_given? ? return_block : lambda { value }
end

def and_throw(symbol)
  @symbol_to_throw = symbol
end

def and_yield(*args, &block)
  if @args_to_yield_were_cloned
    @args_to_yield.clear
    @args_to_yield_were_cloned = false
  end
  
  if block
    require 'rspec/mocks/extensions/instance_exec'
    @eval_context = Object.new
    @eval_context.extend RSpec::Mocks::InstanceExec
    yield @eval_context
  end
  
  @args_to_yield << args
  self
end

def build_child(expected_from, method_block, expected_received_count, opts={})
  child = clone
  child.expected_from = expected_from
  child.method_block = method_block
  child.expected_received_count = expected_received_count
  child.clear_actual_received_count!
  new_gen = error_generator.clone
  new_gen.opts = opts
  child.error_generator = new_gen
  child.clone_args_to_yield @args_to_yield
  child
end

def called_max_times?
  @expected_received_count != :any && @expected_received_count > 0 &&
    @actual_received_count >= @expected_received_count
end

def clone_args_to_yield(args)
  @args_to_yield = args.clone
  @args_to_yield_were_cloned = true
end

def eval_block(*args, &block)
  if @eval_context
    @eval_context.instance_exec(*args, &block)
  else
    block.call(*args)
  end
end

def expected_args
  @args_expectation.args
end

def failed_fast?
  @failed_fast
end

def initialize(error_generator, expectation_ordering, expected_from, sym, method_block, expected_received_count=1, opts={}, &implementation)
  @error_generator = error_generator
  @error_generator.opts = opts
  @expected_from = expected_from
  @sym = sym
  @method_block = method_block
  @return_block = nil
  @actual_received_count = 0
  @expected_received_count = expected_received_count
  @args_expectation = ArgumentExpectation.new([ArgumentMatchers::AnyArgsMatcher.new])
  @consecutive = false
  @exception_to_raise = nil
  @symbol_to_throw = nil
  @order_group = expectation_ordering
  @at_least = nil
  @at_most = nil
  @args_to_yield = []
  @failed_fast = nil
  @args_to_yield_were_cloned = false
  @return_block = implementation
  @eval_context = nil
end

def invoke(args, block)
  if @expected_received_count == 0
    @failed_fast = true
    @actual_received_count += 1
    @error_generator.raise_expectation_error @sym, @expected_received_count, @actual_received_count, *args
  end
  
  @order_group.handle_order_constraint self
  begin
    Kernel::raise @exception_to_raise unless @exception_to_raise.nil?
    Kernel::throw @symbol_to_throw unless @symbol_to_throw.nil?
    
    if !@method_block.nil?
      default_return_val = invoke_method_block(args)
    elsif @args_to_yield.size > 0 || @eval_context
      default_return_val = invoke_with_yield(&block)
    else
      default_return_val = nil
    end
    
    if @consecutive
      return invoke_consecutive_return_block(args, block)
    elsif @return_block
      return invoke_return_block(args, block)
    else
      return default_return_val
    end
  ensure
    @actual_received_count += 1
  end
end

def invoke_consecutive_return_block(args, block)
  value = invoke_return_block(args, block)
  index = [@actual_received_count, value.size-1].min
  value[index]
end

def invoke_method_block(args)
  begin
    @method_block.call(*args)
  rescue => detail
    @error_generator.raise_block_failed_error @sym, detail.message
  end
end

def invoke_return_block(args, block)
  args << block unless block.nil?
  # Ruby 1.9 - when we set @return_block to return values
  # regardless of arguments, any arguments will result in
  # a "wrong number of arguments" error
  @return_block.arity == 0 ? @return_block.call : @return_block.call(*args)
end

def invoke_with_yield(&block)
  if block.nil?
    @error_generator.raise_missing_block_error @args_to_yield
  end
  value = nil
  @args_to_yield.each do |args_to_yield_this_time|
    if block.arity > -1 && args_to_yield_this_time.length != block.arity
      @error_generator.raise_wrong_arity_error args_to_yield_this_time, block.arity
    end
    value = eval_block(*args_to_yield_this_time, &block)
  end
  value
end

def matches(sym, args)
  @sym == sym and @args_expectation.args_match?(args)
end