rspec-expectations 2.0.0.a1 → 2.0.0.a2

data/VERSION

@@ -1 +0,0 @@
-2.0.0.a1

data/VERSION.yml

@@ -1,5 +0,0 @@
---- 
-:patch: 0
-:major: 2
-:minor: 0
-:build: a1

data/lib/rspec/matchers/simple_matcher.rb

@@ -1,133 +0,0 @@
-module Rspec
-  module Matchers
-    class SimpleMatcher
-      attr_writer :failure_message, :negative_failure_message, :description
-      
-      def initialize(description, &match_block)
-        @description = description
-        @match_block = match_block
-        @failure_message = @negative_failure_message = nil
-      end
-
-      def matches?(given)
-        @given = given
-        case @match_block.arity
-        when 2
-          @match_block.call(@given, self)
-        else
-          @match_block.call(@given)
-        end
-      end
-      
-      def description
-        @description || explanation
-      end
-
-      def failure_message_for_should
-        @failure_message || (@description.nil? ? explanation : %[expected #{@description.inspect} but got #{@given.inspect}])
-      end
-
-      def failure_message_for_should_not
-        @negative_failure_message || (@description.nil? ? explanation : %[expected not to get #{@description.inspect}, but got #{@given.inspect}])
-      end
-
-      def explanation
-        "No description provided. See RDoc for simple_matcher()"
-      end
-    end
-  
-    # simple_matcher makes it easy for you to create your own custom matchers
-    # in just a few lines of code when you don't need all the power of a
-    # completely custom matcher object.
-    #
-    # The <tt>description</tt> argument will appear as part of any failure
-    # message, and is also the source for auto-generated descriptions.
-    #
-    # The <tt>match_block</tt> can have an arity of 1 or 2. The first block
-    # argument will be the given value. The second, if the block accepts it
-    # will be the matcher itself, giving you access to set custom failure
-    # messages in favor of the defaults.
-    #
-    # The <tt>match_block</tt> should return a boolean: <tt>true</tt>
-    # indicates a match, which will pass if you use <tt>should</tt> and fail
-    # if you use <tt>should_not</tt>. false (or nil) indicates no match,
-    # which will do the reverse: fail if you use <tt>should</tt> and pass if
-    # you use <tt>should_not</tt>.
-    #
-    # An error in the <tt>match_block</tt> will bubble up, resulting in a
-    # failure.
-    #
-    # == Example with default messages
-    #
-    #   def be_even
-    #     simple_matcher("an even number") { |given| given % 2 == 0 }
-    #   end
-    #                    
-    #   describe 2 do
-    #     it "should be even" do
-    #       2.should be_even
-    #     end
-    #   end
-    #
-    # Given an odd number, this example would produce an error message stating:
-    # expected "an even number", got 3.
-    #
-    # Unfortunately, if you're a fan of auto-generated descriptions, this will
-    # produce "should an even number." Not the most desirable result. You can
-    # control that using custom messages:
-    #
-    # == Example with custom messages
-    #
-    #   def rhyme_with(expected)
-    #     simple_matcher("rhyme with #{expected.inspect}") do |given, matcher|
-    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
-    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
-    #       given.rhymes_with? expected
-    #     end
-    #   end
-    #
-    #   # OR
-    #
-    #   def rhyme_with(expected)
-    #     simple_matcher do |given, matcher|
-    #       matcher.description = "rhyme with #{expected.inspect}"
-    #       matcher.failure_message = "expected #{given.inspect} to rhyme with #{expected.inspect}"
-    #       matcher.negative_failure_message = "expected #{given.inspect} not to rhyme with #{expected.inspect}"
-    #       given.rhymes_with? expected
-    #     end
-    #   end
-    #
-    #   describe "pecan" do
-    #     it "should rhyme with 'be gone'" do
-    #       nut = "pecan"
-    #       nut.extend Rhymer
-    #       nut.should rhyme_with("be gone")
-    #     end
-    #   end
-    #
-    # The resulting messages would be:
-    #   description:              rhyme with "be gone"
-    #   failure_message:          expected "pecan" to rhyme with "be gone"
-    #   negative failure_message: expected "pecan" not to rhyme with "be gone"
-    #
-    # == Wrapped Expectations
-    #
-    # Because errors will bubble up, it is possible to wrap other expectations
-    # in a SimpleMatcher.
-    #
-    #   def be_even
-    #     simple_matcher("an even number") { |given| (given % 2).should == 0 }
-    #   end
-    #
-    # BE VERY CAREFUL when you do this. Only use wrapped expectations for
-    # matchers that will always be used in only the positive
-    # (<tt>should</tt>) or negative (<tt>should_not</tt>), but not both.
-    # The reason is that is you wrap a <tt>should</tt> and call the wrapper
-    # with <tt>should_not</tt>, the correct result (the <tt>should</tt>
-    # failing), will fail when you want it to pass.
-    #
-    def simple_matcher(description=nil, &match_block)
-      SimpleMatcher.new(description, &match_block)
-    end
-  end
-end

data/lib/rspec/matchers/wrap_expectation.rb

@@ -1,55 +0,0 @@
-module Rspec
-  module Matchers
-    # wraps an expectation in a block that will return true if the
-    # expectation passes and false if it fails (without bubbling up
-    # the failure).
-    #     
-    # This is intended to be used in the context of a simple matcher,
-    # and is especially useful for wrapping multiple expectations or
-    # one or more assertions from test/unit extensions when running
-    # with test/unit.
-    #
-    # == Examples
-    #
-    #   def eat_cheese(cheese)
-    #     simple_matcher do |mouse, matcher|
-    #       matcher.failure_message = "expected #{mouse} to eat cheese"
-    #       wrap_expectation do |matcher|
-    #         assert_eats_cheese(mouse)
-    #       end
-    #     end
-    #   end
-    #
-    #   describe Mouse do
-    #     it "eats cheese" do
-    #       Mouse.new.should eat_cheese
-    #     end
-    #   end
-    #
-    # You might be wondering "why would I do this if I could just say"
-    # assert_eats_cheese?", a fair question, indeed. You might prefer
-    # to replace the word assert with something more aligned with the
-    # rest of your code examples. You are using rspec, after all.
-    #
-    # The other benefit you get is that you can use the negative version
-    # of the matcher:
-    #
-    #   describe Cat do
-    #     it "does not eat cheese" do
-    #       Cat.new.should_not eat_cheese
-    #     end
-    #   end
-    #
-    # So in the event there is no assert_does_not_eat_cheese available,
-    # you're all set!
-    def wrap_expectation(matcher, &block)
-      begin
-        block.call(matcher)
-        return true
-      rescue Exception => e
-        matcher.failure_message = e.message
-        return false
-      end
-    end
-  end
-end

data/spec/rspec/expectations/wrap_expectation_spec.rb

@@ -1,30 +0,0 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-module Rspec
-  module Matchers
-    describe "wrap_expectation" do
-      
-      def stub_matcher
-        @_stub_matcher ||= simple_matcher do
-        end
-      end
-      
-      def failing_matcher
-        @_failing_matcher ||= simple_matcher do
-          1.should == 2
-        end
-      end
-      
-      it "should return true if there is no error" do
-        wrap_expectation stub_matcher do
-        end.should be_true
-      end
-      
-      it "should return false if there is an error" do
-        wrap_expectation failing_matcher do
-          raise "error"
-        end.should be_false
-      end
-    end
-  end
-end

data/spec/support/macros.rb

@@ -1,29 +0,0 @@
-module Macros
-  def treats_method_missing_as_private(options = {:noop => true, :subject => nil})
-    it "should have method_missing as private" do
-      with_ruby 1.8 do
-        described_class.private_instance_methods.should include("method_missing")
-      end
-      with_ruby 1.9 do
-        described_class.private_instance_methods.should include(:method_missing)
-      end
-    end
-
-    it "should not respond_to? method_missing (because it's private)" do
-      formatter = options[:subject] || described_class.new({ }, StringIO.new)
-      formatter.should_not respond_to(:method_missing)
-    end
-
-    if options[:noop]
-      it "should respond_to? all messages" do
-        formatter = described_class.new({ }, StringIO.new)
-        formatter.should respond_to(:just_about_anything)
-      end
-
-      it "should respond_to? anything, when given the private flag" do
-        formatter = described_class.new({ }, StringIO.new)
-        formatter.respond_to?(:method_missing, true).should be_true
-      end
-    end
-  end
-end