class RSpec::Expectations::ExpectationTarget

def self.disable_deprecated_should
  return unless deprecated_should_enabled?
  remove_method :should
  remove_method :should_not
  self.deprecated_should_enabled = false
end

def self.enable_deprecated_should
  return if deprecated_should_enabled?
  def should(*args)
    RSpec.deprecate "`expect { }.should`", :replacement => "`expect { }.to`"
    @target.should(*args)
  end
  def should_not(*args)
    RSpec.deprecate "`expect { }.should_not`", :replacement => "`expect { }.not_to`"
    @target.should_not(*args)
  end
  self.deprecated_should_enabled = true
end

def self.for(value, block)
  if UndefinedValue.equal?(value)
    unless block
      raise ArgumentError, "You must pass either an argument or a block to `expect`."
    end
    BlockExpectationTarget.new(block)
  elsif block
    raise ArgumentError, "You cannot pass both an argument and a block to `expect`."
  else
    new(value)
  end
end

def initialize(value)
  @target = value
end

def not_to(matcher=nil, message=nil, &block)
  prevent_operator_matchers(:not_to) unless matcher
  RSpec::Expectations::NegativeExpectationHandler.handle_matcher(@target, matcher, message, &block)
end

def prevent_operator_matchers(verb)
  raise ArgumentError, "The expect syntax does not support operator matchers, " +
                       "so you must pass a matcher to `##{verb}`."
end

def should(*args)
  RSpec.deprecate "`expect { }.should`", :replacement => "`expect { }.to`"
  @target.should(*args)
end

def should_not(*args)
  RSpec.deprecate "`expect { }.should_not`", :replacement => "`expect { }.not_to`"
  @target.should_not(*args)
end

def to(matcher=nil, message=nil, &block)
  prevent_operator_matchers(:to) unless matcher
  RSpec::Expectations::PositiveExpectationHandler.handle_matcher(@target, matcher, message, &block)
end