class Should
  def initialize(source, reverse = false)
    @source = source
    @reverse = reverse
    self
  end

  def ==( arg )
    result = execute_and_check(:==, arg)

    unless result
      raise RuntimeError.new("Expected #{@source} to == #{result}")
    end
    true
  end

  def method_missing(method_name, *args)
    if @source.respond_to?(method_name)
      result = execute_and_check(method_name, *args)

      unless result
        raise RuntimeError.new("Expected #{@source} to #{method_name} #{args.first}")
      end
      true
    else
      super
    end
  end

  def execute_and_check( method_name, *args )
    result = @source.send(method_name, *args)
    boolean_result = @reverse ? !result : result

    boolean_result
  end

end

class Object
  def should
    Should.new(self)
  end

  alias :should_be :should

  def should_not
    Should.new(self, true)
  end

  alias :should_not_be :should_not
end

require 'test/unit'
require 'rubygems'
require 'shoulda'

class ShouldTest < Test::Unit::TestCase
  context "it should" do
    should "work" do
      1.should == 1
      1.should_not == 2
      1.should_be >= 1
      1.should_not_be > 1
      1.should_not_be <= 0
    end

    should "work in the negative" do
      assert_raises(RuntimeError) do
        1.should == 2
      end
    end
  end
end