remq 0.0.1a → 0.0.3

data/vendor/bundle/gems/rspec-expectations-2.12.1/spec/rspec/expectations/differ_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+require 'ostruct'
+
+module RSpec
+  module Expectations
+    describe Differ do
+      context "without --color" do
+
+      before { RSpec::Matchers.configuration.stub(:color? => false) }
+
+      let(:differ) { RSpec::Expectations::Differ.new }
+
+        # color disabled context
+
+      describe '#diff_as_string' do
+        it "outputs unified diff of two strings" do
+          expected="foo\nbar\nzap\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nline\n"
+          actual="foo\nzap\nbar\nthis\nis\nsoo\nvery\nvery\nequal\ninsert\na\nanother\nline\n"
+          expected_diff= <<'EOD'
+
+
+@@ -1,6 +1,6 @@
+ foo
+-zap
+ bar
++zap
+ this
+ is
+ soo
+@@ -9,6 +9,5 @@
+ equal
+ insert
+ a
+-another
+ line
+EOD
+
+          diff = differ.diff_as_string(expected, actual)
+          diff.should eql(expected_diff)
+        end
+      end
+
+      describe '#diff_as_object' do
+        it "outputs unified diff message of two objects" do
+          animal_class = Class.new do
+            def initialize(name, species)
+              @name, @species = name, species
+            end
+
+            def inspect
+              <<-EOA
+<Animal
+  name=#{@name},
+  species=#{@species}
+>
+              EOA
+            end
+          end
+
+          expected = animal_class.new "bob", "giraffe"
+          actual   = animal_class.new "bob", "tortoise"
+
+          expected_diff = <<'EOD'
+
+@@ -1,5 +1,5 @@
+ <Animal
+   name=bob,
+-  species=tortoise
++  species=giraffe
+ >
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+
+        it "outputs a message if the diff is empty" do
+          diff = differ.diff_as_object('foo', 'foo')
+          diff.should eq(
+            "foo.==(foo) returned false even though the diff between " \
+            "foo and foo is empty. Check the implementation of foo.==."
+          )
+        end
+
+        it "outputs unified diff message of two arrays" do
+          expected = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'charlie', :width, 'quite wide' ]
+          actual   = [ :foo, 'bar', :baz, 'quux', :metasyntactic, 'variable', :delta, 'tango'  , :width, 'very wide'  ]
+
+          expected_diff = <<'EOD'
+
+
+@@ -5,7 +5,7 @@
+  :metasyntactic,
+  "variable",
+  :delta,
+- "tango",
++ "charlie",
+  :width,
+- "very wide"]
++ "quite wide"]
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+
+        it "outputs unified diff message of two hashes" do
+          expected = { :foo => 'bar', :baz => 'quux', :metasyntactic => 'variable', :delta => 'charlie', :width =>'quite wide' }
+          actual   = { :foo => 'bar', :metasyntactic => 'variable', :delta => 'charlotte', :width =>'quite wide' }
+
+          expected_diff = <<'EOD'
+
+@@ -1,4 +1,5 @@
+-:delta => "charlotte",
++:baz => "quux",
++:delta => "charlie",
+ :foo => "bar",
+ :metasyntactic => "variable",
+ :width => "quite wide"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+
+        it "outputs unified diff of single line strings" do
+          expected = "this is one string"
+          actual   = "this is another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,2 +1,2 @@
+-"this is another string"
++"this is one string"
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+
+        it "outputs unified diff of multi line strings" do
+          expected = "this is:\n  one string"
+          actual   = "this is:\n  another string"
+
+          expected_diff = <<'EOD'
+
+@@ -1,3 +1,3 @@
+ this is:
+-  another string
++  one string
+EOD
+
+          diff = differ.diff_as_object(expected,actual)
+          diff.should == expected_diff
+        end
+      end
+    end
+
+    context "with --color" do
+      before { RSpec::Matchers.configuration.stub(:color? => true) }
+
+      let(:differ) { RSpec::Expectations::Differ.new }
+
+      it "outputs colored diffs" do
+        expected = "foo bar baz"
+        actual = "foo bang baz"
+        expected_diff = "\n\e[34m@@ -1,2 +1,2 @@\n\e[0m\e[31m-foo bang baz\n\e[0m\e[32m+foo bar baz\n\e[0m"
+
+
+        diff = differ.diff_as_string(expected,actual)
+        diff.should == expected_diff
+      end
+    end
+
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/spec/rspec/expectations/expectation_target_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module RSpec
+  module Expectations
+    # so our examples below can set expectations about the target
+    ExpectationTarget.send(:attr_reader, :target)
+
+    describe ExpectationTarget do
+      context 'when constructed via #expect' do
+        it 'constructs a new instance targetting the given argument' do
+          expect(7).target.should eq(7)
+        end
+
+        it 'constructs a new instance targetting the given block' do
+          block = lambda {}
+          expect(&block).target.should be(block)
+        end
+
+        it 'raises an ArgumentError when given an argument and a block' do
+          lambda { expect(7) { } }.should raise_error(ArgumentError)
+        end
+
+        it 'raises an ArgumentError when given neither an argument nor a block' do
+          lambda { expect }.should raise_error(ArgumentError)
+        end
+
+        it 'can be passed nil' do
+          expect(nil).target.should be_nil
+        end
+
+        it 'passes a valid positive expectation' do
+          expect(5).to eq(5)
+        end
+
+        it 'passes a valid negative expectation' do
+          expect(5).to_not eq(4)
+          expect(5).not_to eq(4)
+        end
+
+        it 'fails an invalid positive expectation' do
+          lambda { expect(5).to eq(4) }.should fail_with(/expected: 4.*got: 5/m)
+        end
+
+        it 'fails an invalid negative expectation' do
+          message = /expected 5 not to be a kind of Fixnum/
+          lambda { expect(5).to_not be_a(Fixnum) }.should fail_with(message)
+          lambda { expect(5).not_to be_a(Fixnum) }.should fail_with(message)
+        end
+
+        it 'does not support operator matchers from #to' do
+          expect {
+            expect(3).to == 3
+          }.to raise_error(ArgumentError)
+        end
+
+        it 'does not support operator matchers from #not_to' do
+          expect {
+            expect(3).not_to == 4
+          }.to raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end
+

data/vendor/bundle/gems/rspec-expectations-2.12.1/spec/rspec/expectations/extensions/kernel_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe Object, "#should" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+    @matcher.stub!(:matches?).and_return(true)
+    @matcher.stub!(:failure_message_for_should)
+  end
+  
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)    
+    @target.should @matcher
+  end
+  
+  it "asks for a failure_message_for_should when matches? returns false" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.should_receive(:failure_message_for_should).and_return("the failure message")
+    lambda {
+      @target.should @matcher
+    }.should fail_with("the failure message")
+  end
+
+  context "on interpretters that have BasicObject", :if => defined?(BasicObject) do
+    let(:proxy_class) do
+      Class.new(BasicObject) do
+        def initialize(target)
+          @target = target
+        end
+
+        def proxied?
+          true
+        end
+
+        def method_missing(name, *args)
+          @target.send(name, *args)
+        end
+      end
+    end
+
+    it 'works properly on BasicObject-subclassed proxy objects' do
+      proxy_class.new(Object.new).should be_proxied
+    end
+  end
+end
+
+describe Object, "#should_not" do
+  before(:each) do
+    @target = "target"
+    @matcher = mock("matcher")
+  end
+  
+  it "accepts and interacts with a matcher" do
+    @matcher.should_receive(:matches?).with(@target).and_return(false)
+    @matcher.stub!(:failure_message_for_should_not)
+    
+    @target.should_not @matcher
+  end
+  
+  it "asks for a failure_message_for_should_not when matches? returns true" do
+    @matcher.should_receive(:matches?).with(@target).and_return(true)
+    @matcher.should_receive(:failure_message_for_should_not).and_return("the failure message for should not")
+    lambda {
+      @target.should_not @matcher
+    }.should fail_with("the failure message for should not")
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/spec/rspec/expectations/fail_with_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe RSpec::Expectations, "#fail_with with diff" do
+  let(:differ) { double("differ") }
+
+  before(:each) do
+    RSpec::Expectations.stub(:differ) { differ }
+  end
+
+  it "calls differ if expected/actual are not strings (or numbers or procs)" do
+    differ.should_receive(:diff_as_object).and_return("diff")
+    lambda {
+      RSpec::Expectations.fail_with "the message", Object.new, Object.new
+    }.should fail_with("the message\nDiff:diff")
+  end
+
+  context "with two strings" do
+    context "and actual is multiline" do
+      it "calls differ" do
+        differ.should_receive(:diff_as_string).and_return("diff")
+        lambda {
+          RSpec::Expectations.fail_with "the message", "expected\nthis", "actual"
+        }.should fail_with("the message\nDiff:diff")
+      end
+    end
+
+    context "and expected is multiline" do
+      it "calls differ" do
+        differ.should_receive(:diff_as_string).and_return("diff")
+        lambda {
+          RSpec::Expectations.fail_with "the message", "expected", "actual\nthat"
+        }.should fail_with("the message\nDiff:diff")
+      end
+    end
+
+    context "and both are single line strings" do
+      it "does not call differ" do
+        differ.should_not_receive(:diff_as_string)
+        lambda {
+          RSpec::Expectations.fail_with("the message", "expected", "actual")
+        }.should fail_with("the message")
+      end
+    end
+  end
+
+  it "does not call differ if no expected/actual" do
+    lambda {
+      RSpec::Expectations.fail_with "the message"
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ expected is Numeric" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", 1, "1"
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ when actual is Numeric" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", "1", 1
+    }.should fail_with("the message")
+  end
+
+  it "does not call differ if expected or actual are procs" do
+    lambda {
+      RSpec::Expectations.fail_with "the message", lambda {}, lambda {}
+    }.should fail_with("the message")
+  end
+end
+

data/vendor/bundle/gems/rspec-expectations-2.12.1/spec/rspec/expectations/handler_spec.rb

@@ -0,0 +1,206 @@
+require 'spec_helper'
+
+module ExampleExpectations
+
+  class ArbitraryMatcher
+    def initialize(*args, &block)
+      if args.last.is_a? Hash
+        @expected = args.last[:expected]
+      end
+      @expected = block.call if block
+      @block = block
+    end
+
+    def matches?(target)
+      @target = target
+      return @expected == target
+    end
+
+    def with(new_value)
+      @expected = new_value
+      self
+    end
+
+    def failure_message
+      "expected #{@expected}, got #{@target}"
+    end
+
+    def negative_failure_message
+      "expected not #{@expected}, got #{@target}"
+    end
+  end
+
+  class PositiveOnlyMatcher < ArbitraryMatcher
+    undef negative_failure_message rescue nil
+  end
+
+  def arbitrary_matcher(*args, &block)
+    ArbitraryMatcher.new(*args, &block)
+  end
+
+  def positive_only_matcher(*args, &block)
+    PositiveOnlyMatcher.new(*args, &block)
+  end
+
+end
+
+module RSpec
+  module Expectations
+    describe PositiveExpectationHandler do
+      describe "#handle_matcher" do
+        it "asks the matcher if it matches" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(true)
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "returns the match value" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(:this_value)
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher).should == :this_value
+        end
+
+        it "calls failure_message_for_should if the matcher implements it" do
+          matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false)
+          actual = Object.new
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "calls fail if matcher.diffable?" do
+          matcher = mock("matcher",
+            :diffable? => true,
+            :failure_message_for_should => "message",
+            :matches? => false,
+            :expected => 1,
+            :actual   => 2
+          )
+          actual = Object.new
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("message", 1, 2)
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "calls failure_message if the matcher does not implement failure_message_for_should" do
+          matcher = mock("matcher", :failure_message => "message", :matches? => false)
+          actual = Object.new
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher)
+
+        end
+
+        it "appends the :or message in the options hash passed to should" do
+          matcher = mock("matcher", :failure_message_for_should => "message", :matches? => false)
+          actual = Object.new
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+
+          RSpec::Expectations::PositiveExpectationHandler.handle_matcher(actual, matcher, "custom")
+        end
+      end
+    end
+
+    describe NegativeExpectationHandler do
+      describe "#handle_matcher" do
+        it "asks the matcher if it doesn't match when the matcher responds to #does_not_match?" do
+          matcher = mock("matcher", :does_not_match? => true, :negative_failure_message => nil)
+          actual = Object.new
+          matcher.should_receive(:does_not_match?).with(actual).and_return(true)
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "asks the matcher if it matches when the matcher doesn't respond to #does_not_match?" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.stub!(:negative_failure_message)
+          matcher.should_receive(:matches?).with(actual).and_return(false)
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "returns the match value" do
+          matcher = mock("matcher")
+          actual = Object.new
+          matcher.should_receive(:matches?).with(actual).and_return(false)
+          matcher.stub!(:negative_failure_message).and_return("ignore")
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher).should be_false
+        end
+
+
+        it "calls failure_message_for_should_not if the matcher implements it" do
+          matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          actual = Object.new
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+
+        end
+
+        it "calls negative_failure_message if the matcher does not implement failure_message_for_should_not" do
+          matcher = mock("matcher", :negative_failure_message => "message", :matches? => true)
+          actual = Object.new
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("message")
+
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+
+        end
+
+
+        it "calls fail if matcher.diffable?" do
+          matcher = mock("matcher",
+            :diffable? => true,
+            :failure_message_for_should_not => "message",
+            :matches? => true,
+            :expected => 1,
+            :actual   => 2
+          )
+          actual = Object.new
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("message", 1, 2)
+
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher)
+        end
+
+        it "appends the :or message in the options hash passed to should" do
+          matcher = mock("matcher", :failure_message_for_should_not => "message", :matches? => true)
+          actual = Object.new
+
+          ::RSpec::Expectations.should_receive(:fail_with).with("custom")
+
+          RSpec::Expectations::NegativeExpectationHandler.handle_matcher(actual, matcher, "custom")
+        end
+
+      end
+    end
+
+    describe PositiveExpectationHandler do
+      include ExampleExpectations
+
+      it "handles submitted args" do
+        5.should arbitrary_matcher(:expected => 5)
+        5.should arbitrary_matcher(:expected => "wrong").with(5)
+        lambda { 5.should arbitrary_matcher(:expected => 4) }.should fail_with("expected 4, got 5")
+        lambda { 5.should arbitrary_matcher(:expected => 5).with(4) }.should fail_with("expected 4, got 5")
+        5.should_not arbitrary_matcher(:expected => 4)
+        5.should_not arbitrary_matcher(:expected => 5).with(4)
+        lambda { 5.should_not arbitrary_matcher(:expected => 5) }.should fail_with("expected not 5, got 5")
+        lambda { 5.should_not arbitrary_matcher(:expected => 4).with(5) }.should fail_with("expected not 5, got 5")
+      end
+
+      it "handles the submitted block" do
+        5.should arbitrary_matcher { 5 }
+        5.should arbitrary_matcher(:expected => 4) { 5 }
+        5.should arbitrary_matcher(:expected => 4).with(5) { 3 }
+      end
+
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/spec/rspec/expectations/syntax_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module RSpec
+  module Expectations
+    module Syntax
+      describe "the should and should_not expectations" do
+        let(:warner) { ::Kernel }
+
+        describe "#should" do
+          it "prints a warning when the message object isn't a String" do
+            warner.should_receive(:warn).with /ignoring.*message/
+            3.should eq(3), :not_a_string
+          end
+
+          it "doesn't print a warning when message is a String" do
+            warner.should_not_receive(:warn)
+            3.should eq(3), "a string"
+          end
+        end
+
+        describe "#should_not" do
+          it "prints a warning when the message object isn't a String" do
+            warner.should_receive(:warn).with /ignoring.*message/
+            3.should_not eq(4), :not_a_string
+          end
+
+          it "doesn't print a warning when message is a String" do
+            warner.should_not_receive(:warn)
+            3.should_not eq(4), "a string"
+          end
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/gems/rspec-expectations-2.12.1/spec/rspec/matchers/base_matcher_spec.rb

@@ -0,0 +1,60 @@
+module RSpec::Matchers::BuiltIn
+  describe BaseMatcher do
+    describe "#match_unless_raises" do
+      let(:matcher) do
+        Class.new(BaseMatcher).new
+      end
+
+      it "returns true if there are no errors" do
+        matcher.match_unless_raises {}.should be_true
+      end
+
+      it "returns false if there is an error" do
+        matcher.match_unless_raises { raise }.should be_false
+      end
+
+      it "returns false if the only submitted error is raised" do
+        matcher.match_unless_raises(RuntimeError){ raise "foo" }.should be_false
+      end
+
+      it "returns false if any of several errors submitted is raised" do
+        matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise "foo" }.should be_false
+        matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise ArgumentError.new('') }.should be_false
+        matcher.match_unless_raises(RuntimeError, ArgumentError, NameError) { raise NameError.new('') }.should be_false
+      end
+
+      it "re-raises any error other than one of those specified" do
+        expect do
+          matcher.match_unless_raises(ArgumentError){ raise "foo" }
+        end.to raise_error
+      end
+
+      it "stores the rescued exception for use in messages" do
+        matcher.match_unless_raises(RuntimeError){ raise "foo" }
+        matcher.rescued_exception.should be_a(RuntimeError)
+        matcher.rescued_exception.message.should eq("foo")
+      end
+
+    end
+
+    describe "#==" do
+      it "responds the same way as matches?" do
+        matcher = Class.new(BaseMatcher) do
+          def initialize(expected)
+            @expected = expected
+          end
+
+          def matches?(actual)
+            (@actual = actual) == @expected
+          end
+        end
+
+        matcher.new(3).matches?(3).should be_true
+        matcher.new(3).should eq(3)
+
+        matcher.new(3).matches?(4).should be_false
+        matcher.new(3).should_not eq(4)
+      end
+    end
+  end
+end