Beginning with 0.8.0, RSpec is moving towards a new syntax using Expression Matchers
instead of adding expectations directly to Object. We'll still be adding a few methods
to Object, but it will be much less invasive, and will eliminate conflicts with
other tools and frameworks that utilize method_missing to perform magic.

For more information on Expression Matchers, see the rdoc for Spec::Matchers

Our plan is as follows:

* release 0.8.0 with:
  - full support for Expression Matchers
  - a translation tool that will convert the majority of your specs from the old syntax to the new syntax
  - deprecation warnings for all of the old methods that will be removed
* release 0.9.0 with all of the old methods removed

Everything that is listed below is already supported and usable right now.

== General: should_xyz

  #before
  actual.should_xyz expected
  actual.should_not_xyz expected

  #after
  actual.should xyz(expected)
  actual.should_not xyz(expected)

This change applies to all of these as well:

  should_equal
  should_eql
  should_be_close
  should_include
  should_match
  should_satisfy

== should_be

  #before
  result.should_be true
  result.should_be false
  result.should_be nil
  result.should_not_be nil

  #after
  result.should be(true)
  result.should be(false)
  result.should be(nil)
  result.should_not be(true)

== should_be with arbitrary predicates

  #before
  true.should_be_arbitrary_predicate
  true.should_be_a_arbitrary_predicate
  true.should_be_an_arbitrary_predicate

  #after
  true.should be_arbitrary_predicate
  true.should be_a_arbitrary_predicate
  true.should be_an_arbitrary_predicate

== should_be with comparison operators

  #before
  5.should_be > 3
  4.should_be >= 4
  4.should_be <= 4
  4.should_be < 4

  #before
  5.should be > 3
  4.should be >= 4
  4.should be <= 4
  4.should be < 4
  
== should ==

  #before
  actual.should == expected
  actual.should_not == expected
  
  #after - exactly the same
  actual.should == expected
  actual.should_not == expected

== should =~

  #before
  actual.should =~ regexp
  actual.should_not =~ regexp

  #after - exactly the same
  actual.should =~ regexp
  actual.should_not =~ regexp
  
== should_have

  #before
  team.should_have(3).players
  hash.should_have_key(:a)

  #after
  team.should have(3).players
  hash.should have_key(:a)

== should_change

  #before
  proc.should_change(:target, message)
  proc.should_change(:target, message).by(1)
  proc.should_change(:target, message).from("a").to("b")
  
  proc.should change(:target, message)
  proc.should change(:target, message).by(1)
  proc.should change(:target, message).from("a").to("b")
  