module RSpec::Matchers

def self.clear_generated_description
  self.last_matcher = nil
  self.last_should = nil
end

def self.configuration
  @configuration ||= Expectations::Configuration.new
end

def self.const_missing(name)
  case name
    when :OperatorMatcher
      RSpec.deprecate("`RSpec::Matchers::OperatorMatcher`",
                      :replacement => "`RSpec::Matchers::BuiltIn::OperatorMatcher`")
      BuiltIn::OperatorMatcher
    when :Configuration
      RSpec.deprecate("`RSpec::Matchers::Configuration`",
                      :replacement => "`RSpec::Expectations::Configuration`")
      Expectations::Configuration
    else super
  end
end

def self.generated_description
  return nil if last_should.nil?
  "#{last_should.to_s.gsub('_',' ')} #{last_description}"
end

def self.is_a_matcher?(obj)
  return true  if ::RSpec::Matchers::BuiltIn::BaseMatcher === obj
  return false if obj.respond_to?(:i_respond_to_everything_so_im_not_really_a_matcher)
  return false unless obj.respond_to?(:matches?)
  obj.respond_to?(:failure_message_for_should) || obj.respond_to?(:failure_message)
end

def self.last_description
  last_matcher.respond_to?(:description) ? last_matcher.description : <<-MESSAGE
 you call a matcher in an example without a String, like this:
ify { object.should matcher }
his:
 should matcher }
c expects the matcher to have a #description method. You should either
a String to the example this matcher is being used in, or give it a
ription method. Then you won't have to suffer this lengthy warning again.
AGE
end

def be(*args)
  args.empty? ?
    Matchers::BuiltIn::Be.new : equal(*args)
end

def be_a(klass)
  be_a_kind_of(klass)
end

def be_a_kind_of(expected)
  BuiltIn::BeAKindOf.new(expected)
end

def be_an_instance_of(expected)
  BuiltIn::BeAnInstanceOf.new(expected)
end

def be_close(expected, delta)
  RSpec.deprecate("be_close(#{expected}, #{delta})",
    :replacement => "be_within(#{delta}).of(#{expected})",
    :type        => 'the be_close matcher'
  )
  be_within(delta).of(expected)
end

def be_false
  RSpec.deprecate("`be_false`", :replacement =>
    "`be_falsey` (for Ruby's conditional semantics) or " +
    "`be false` (for exact `== false` equality)"
  )
  BuiltIn::BeFalsey.new
end

def be_falsey
  BuiltIn::BeFalsey.new
end

def be_nil
  BuiltIn::BeNil.new
end

def be_true
  RSpec.deprecate("`be_true`", :replacement =>
    "`be_truthy` (for Ruby's conditional semantics) or " +
    "`be true` (for exact `== true` equality)"
  )
  BuiltIn::BeTruthy.new
end

def be_truthy
  BuiltIn::BeTruthy.new
end

def be_within(delta)
  BuiltIn::BeWithin.new(delta)
end

def change(receiver=nil, message=nil, &block)
  BuiltIn::Change.new(receiver, message, &block)
end

def cover(*values)
  BuiltIn::Cover.new(*values)
end if (1..2).respond_to?(:cover?)

def end_with(*expected)
  BuiltIn::EndWith.new(*expected)
end

def eq(expected)
  BuiltIn::Eq.new(expected)
end

def eql(expected)
  BuiltIn::Eql.new(expected)
end

def equal(expected)
  BuiltIn::Equal.new(expected)
end

def exist(*args)
  BuiltIn::Exist.new(*args)
end

def have(n)
  BuiltIn::Have.new(n)
end

def have_at_least(n)
  BuiltIn::Have.new(n, :at_least)
end

def have_at_most(n)
  BuiltIn::Have.new(n, :at_most)
end

def include(*expected)
  BuiltIn::Include.new(*expected)
end

def match(expected)
  BuiltIn::Match.new(expected)
end

def match_array(array)
  BuiltIn::MatchArray.new(array)
end

def method_missing(method, *args, &block)
  return Matchers::BuiltIn::BePredicate.new(method, *args, &block) if method.to_s =~ /^be_/
  return Matchers::BuiltIn::Has.new(method, *args, &block) if method.to_s =~ /^have_/
  super
end

def raise_error(error=Exception, message=nil, &block)
  BuiltIn::RaiseError.new(error, message, &block)
end

def respond_to(*names)
  BuiltIn::RespondTo.new(*names)
end

def satisfy(&block)
  BuiltIn::Satisfy.new(&block)
end

def start_with(*expected)
  BuiltIn::StartWith.new(*expected)
end

def throw_symbol(expected_symbol=nil, expected_arg=nil)
  BuiltIn::ThrowSymbol.new(expected_symbol, expected_arg)
end

def yield_control
  BuiltIn::YieldControl.new
end

def yield_successive_args(*args)
  BuiltIn::YieldSuccessiveArgs.new(*args)
end

def yield_with_args(*args)
  BuiltIn::YieldWithArgs.new(*args)
end

def yield_with_no_args
  BuiltIn::YieldWithNoArgs.new
end