remq 0.0.1a → 0.0.3

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

@@ -0,0 +1,437 @@
+require 'spec_helper'
+
+module YieldHelpers
+  # these helpers are prefixed with an underscore to prevent
+  # collisions with the matchers (some of which have the same names)
+  def _dont_yield
+  end
+
+  def _yield_with_no_args
+    yield
+  end
+
+  def _yield_with_args(*args)
+    yield(*args)
+  end
+end
+
+class InstanceEvaler
+  include RSpec::Matchers::Extensions::InstanceEvalWithArgs
+
+  def yield_with_no_args(&block)
+    instance_eval_with_args(&block)
+  end
+
+  def yield_with_args(*args, &block)
+    instance_eval_with_args(*args, &block)
+  end
+
+  def each_arg(*args, &block)
+    args.each do |arg|
+      instance_eval_with_args(arg, &block)
+    end
+  end
+end
+
+describe "yield_control matcher" do
+  include YieldHelpers
+  extend  YieldHelpers
+
+  it_behaves_like "an RSpec matcher",
+      :valid_value => lambda { |b| _yield_with_no_args(&b) },
+      :invalid_value => lambda { |b| _dont_yield(&b) } do
+    let(:matcher) { yield_control }
+  end
+
+  it 'has a description' do
+    yield_control.description.should eq("yield control")
+  end
+
+  describe "expect {...}.to yield_control" do
+    it 'passes if the block yields, regardless of the number of yielded arguments' do
+      expect { |b| _yield_with_no_args(&b) }.to yield_control
+      expect { |b| _yield_with_args(1, 2, &b) }.to yield_control
+    end
+
+    it 'passes if the block yields using instance_eval' do
+      expect { |b| InstanceEvaler.new.yield_with_no_args(&b) }.to yield_control
+    end
+
+    it 'fails if the block does not yield' do
+      expect {
+        expect { |b| _dont_yield(&b) }.to yield_control
+      }.to fail_with(/expected given block to yield control/)
+    end
+
+    it 'raises an error if it yields multiple times' do
+      expect {
+        expect { |b| [1, 2].each(&b) }.to yield_control
+      }.to raise_error(/not designed.*yields multiple times/)
+    end
+  end
+
+  describe "expect {...}.not_to yield_control" do
+    it 'passes if the block does not yield' do
+      expect { |b| _dont_yield(&b) }.not_to yield_control
+    end
+
+    it 'fails if the block does yield' do
+      expect {
+        expect { |b| _yield_with_no_args(&b) }.not_to yield_control
+      }.to fail_with(/expected given block not to yield control/)
+    end
+
+    it 'fails if the expect block does not accept an argument' do
+      expect {
+        expect { }.not_to yield_control
+      }.to raise_error(/expect block must accept an argument/)
+    end
+
+    it 'raises an error if the expect block arg is not passed to a method as a block' do
+      expect {
+        expect { |b| }.not_to yield_control
+      }.to raise_error(/must pass the argument.*as a block/)
+    end
+  end
+end
+
+describe "yield_with_no_args matcher" do
+  include YieldHelpers
+  extend  YieldHelpers
+
+  it_behaves_like "an RSpec matcher",
+      :valid_value => lambda { |b| _yield_with_no_args(&b) },
+      :invalid_value => lambda { |b| _dont_yield(&b) } do
+    let(:matcher) { yield_with_no_args }
+  end
+
+  it 'has a description' do
+    yield_with_no_args.description.should eq("yield with no args")
+  end
+
+  describe "expect {...}.to yield_with_no_args" do
+    it 'passes if the block yields with no args' do
+      expect { |b| _yield_with_no_args(&b) }.to yield_with_no_args
+    end
+
+    it 'passes if the block yields with no args using instance_eval' do
+      expect { |b| InstanceEvaler.new.yield_with_no_args(&b) }.to yield_with_no_args
+    end
+
+    it 'fails if the block does not yield' do
+      expect {
+        expect { |b| _dont_yield(&b) }.to yield_with_no_args
+      }.to fail_with(/expected given block to yield with no arguments, but did not yield/)
+    end
+
+    it 'fails if the block yields with args' do
+      expect {
+        expect { |b| _yield_with_args(1, &b) }.to yield_with_no_args
+      }.to fail_with(/expected given block to yield with no arguments, but yielded with arguments/)
+    end
+
+    it 'fails if the block yields with arg false' do
+      expect {
+        expect { |b| _yield_with_args(false, &b) }.to yield_with_no_args
+      }.to fail_with(/expected given block to yield with no arguments, but yielded with arguments/)
+    end
+
+    it 'raises an error if it yields multiple times' do
+      expect {
+        expect { |b| [1, 2].each(&b) }.to yield_with_no_args
+      }.to raise_error(/not designed.*yields multiple times/)
+    end
+  end
+
+  describe "expect {...}.not_to yield_with_no_args" do
+    it "passes if the block does not yield" do
+      expect { |b| _dont_yield(&b) }.not_to yield_with_no_args
+    end
+
+    it "passes if the block yields with args" do
+      expect { |b| _yield_with_args(1, &b) }.not_to yield_with_no_args
+    end
+
+    it "fails if the block yields with no args" do
+      expect {
+        expect { |b| _yield_with_no_args(&b) }.not_to yield_with_no_args
+      }.to fail_with(/expected given block not to yield with no arguments, but did/)
+    end
+
+    it 'fails if the expect block does not accept an argument' do
+      expect {
+        expect { }.not_to yield_with_no_args
+      }.to raise_error(/expect block must accept an argument/)
+    end
+
+    it 'raises an error if the expect block arg is not passed to a method as a block' do
+      expect {
+        expect { |b| }.not_to yield_with_no_args
+      }.to raise_error(/must pass the argument.*as a block/)
+    end
+  end
+end
+
+describe "yield_with_args matcher" do
+  include YieldHelpers
+  extend  YieldHelpers
+
+  it_behaves_like "an RSpec matcher",
+      :valid_value => lambda { |b| _yield_with_args(1, &b) },
+      :invalid_value => lambda { |b| _dont_yield(&b) } do
+    let(:matcher) { yield_with_args }
+  end
+
+  it 'has a description' do
+    yield_with_args.description.should eq("yield with args")
+    yield_with_args(1, 3).description.should eq("yield with args(1, 3)")
+    yield_with_args(false).description.should eq("yield with args(false)")
+  end
+
+  describe "expect {...}.to yield_with_args" do
+    it 'passes if the block yields with arguments' do
+      expect { |b| _yield_with_args(1, &b) }.to yield_with_args
+    end
+
+    it 'fails if the block does not yield' do
+      expect {
+        expect { |b| _dont_yield(&b) }.to yield_with_args
+      }.to fail_with(/expected given block to yield with arguments, but did not yield/)
+    end
+
+    it 'fails if the block yields with no arguments' do
+      expect {
+        expect { |b| _yield_with_no_args(&b) }.to yield_with_args
+      }.to fail_with(/expected given block to yield with arguments, but yielded with no arguments/)
+    end
+
+    it 'raises an error if it yields multiple times' do
+      expect {
+        expect { |b| [1, 2].each(&b) }.to yield_with_args
+      }.to raise_error(/not designed.*yields multiple times/)
+    end
+  end
+
+  describe "expect {...}.not_to yield_with_args" do
+    it 'fails if the block yields with arguments' do
+      expect {
+        expect { |b| _yield_with_args(1, &b) }.not_to yield_with_args
+      }.to fail_with(/expected given block not to yield with arguments, but did/)
+    end
+
+    it 'passes if the block does not yield' do
+      expect { |b| _dont_yield(&b) }.not_to yield_with_args
+    end
+
+    it 'passes if the block yields with no arguments' do
+      expect { |b| _yield_with_no_args(&b) }.not_to yield_with_args
+    end
+
+    it 'fails if the expect block does not accept an argument' do
+      expect {
+        expect { }.not_to yield_with_args
+      }.to raise_error(/expect block must accept an argument/)
+    end
+
+    it 'raises an error if the expect block arg is not passed to a method as a block' do
+      expect {
+        expect { |b| }.not_to yield_with_args
+      }.to raise_error(/must pass the argument.*as a block/)
+    end
+  end
+
+  describe "expect {...}.to yield_with_args(3, 17)" do
+    it 'passes if the block yields with the given arguments' do
+      expect { |b| _yield_with_args(3, 17, &b) }.to yield_with_args(3, 17)
+    end
+
+    it 'passes if the block yields with the given arguments using instance_eval' do
+      expect { |b| InstanceEvaler.new.yield_with_args(3, 17, &b) }.to yield_with_args(3, 17)
+    end
+
+    it 'fails if the block does not yield' do
+      expect {
+        expect { |b| _dont_yield(&b) }.to yield_with_args(3, 17)
+      }.to fail_with(/expected given block to yield with arguments, but did not yield/)
+    end
+
+    it 'fails if the block yields with no arguments' do
+      expect {
+        expect { |b| _yield_with_no_args(&b) }.to yield_with_args(3, 17)
+      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
+    end
+
+    it 'fails if the block yields with different arguments' do
+      expect {
+        expect { |b| _yield_with_args("a", "b", &b) }.to yield_with_args("a", "c")
+      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
+    end
+  end
+
+  describe "expect {...}.not_to yield_with_args(3, 17)" do
+    it 'passes if the block yields with different arguments' do
+      expect { |b| _yield_with_args("a", "b", &b) }.not_to yield_with_args("a", "c")
+    end
+
+    it 'fails if the block yields with the given arguments' do
+      expect {
+        expect { |b| _yield_with_args("a", "b", &b) }.not_to yield_with_args("a", "b")
+      }.to fail_with(/expected given block not to yield with arguments, but yielded with expected arguments/)
+    end
+  end
+
+  describe "expect {...}.to yield_with_args( false )" do
+    it 'passes if the block yields with the given arguments' do
+      expect { |b| _yield_with_args(false, &b) }.to yield_with_args(false)
+    end
+
+    it 'passes if the block yields with the given arguments using instance_eval' do
+      expect { |b| InstanceEvaler.new.yield_with_args(false, &b) }.to yield_with_args(false)
+    end
+
+    it 'fails if the block does not yield' do
+      expect {
+        expect { |b| _dont_yield(&b) }.to yield_with_args(false)
+      }.to fail_with(/expected given block to yield with arguments, but did not yield/)
+    end
+
+    it 'fails if the block yields with no arguments' do
+      expect {
+        expect { |b| _yield_with_no_args(&b) }.to yield_with_args(false)
+      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
+    end
+
+    it 'fails if the block yields with different arguments' do
+      expect {
+        expect { |b| _yield_with_args(false, &b) }.to yield_with_args(true)
+      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
+    end
+  end
+
+  describe "expect {...}.to yield_with_args(/reg/, /ex/)" do
+    it "passes if the block yields strings matching the regexes" do
+      expect { |b| _yield_with_args("regular", "expression", &b) }.to yield_with_args(/reg/, /ex/)
+    end
+
+    it "fails if the block yields strings that do not match the regexes" do
+      expect {
+        expect { |b| _yield_with_args("no", "match", &b) }.to yield_with_args(/reg/, /ex/)
+      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
+    end
+  end
+
+  describe "expect {...}.to yield_with_args(String, Fixnum)" do
+    it "passes if the block yields objects of the given types" do
+      expect { |b| _yield_with_args("string", 15, &b) }.to yield_with_args(String, Fixnum)
+    end
+
+    it "passes if the block yields the given types" do
+      expect { |b| _yield_with_args(String, Fixnum, &b) }.to yield_with_args(String, Fixnum)
+    end
+
+    it "fails if the block yields objects of different types" do
+      expect {
+        expect { |b| _yield_with_args(15, "string", &b) }.to yield_with_args(String, Fixnum)
+      }.to fail_with(/expected given block to yield with arguments, but yielded with unexpected arguments/)
+    end
+  end
+end
+
+describe "yield_successive_args matcher" do
+  include YieldHelpers
+  extend  YieldHelpers
+
+  it_behaves_like "an RSpec matcher",
+      :valid_value => lambda { |b| [1, 2].each(&b) },
+      :invalid_value => lambda { |b| _dont_yield(&b) } do
+    let(:matcher) { yield_successive_args(1, 2) }
+  end
+
+  it 'has a description' do
+    yield_successive_args(1, 3).description.should eq("yield successive args(1, 3)")
+    yield_successive_args([:a, 1], [:b, 2]).description.should eq("yield successive args([:a, 1], [:b, 2])")
+  end
+
+  describe "expect {...}.to yield_successive_args([:a, 1], [:b, 2])" do
+    it 'passes when the block successively yields the given args' do
+      expect { |b| [ [:a, 1], [:b, 2] ].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+    end
+
+    it 'fails when the block does not yield that many times' do
+      expect {
+        expect { |b| [[:a, 1]].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+      }.to fail_with(/but yielded with unexpected arguments/)
+    end
+
+    it 'fails when the block yields the right number of times but with different arguments' do
+      expect {
+        expect { |b| [ [:a, 1], [:b, 3] ].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+      }.to fail_with(/but yielded with unexpected arguments/)
+    end
+  end
+
+  describe "expect {...}.to yield_successive_args(1, 2, 3)" do
+    it 'passes when the block successively yields the given args' do
+      expect { |b| [1, 2, 3].each(&b) }.to yield_successive_args(1, 2, 3)
+    end
+
+    it 'passes when the block successively yields the given args using instance_eval' do
+      expect { |b| InstanceEvaler.new.each_arg(1, 2, 3, &b) }.to yield_successive_args(1, 2, 3)
+    end
+
+    it 'fails when the block does not yield the expected args' do
+      expect {
+        expect { |b| [1, 2, 4].each(&b) }.to yield_successive_args([:a, 1], [:b, 2])
+      }.to fail_with(/but yielded with unexpected arguments/)
+    end
+  end
+
+  describe "expect {...}.not_to yield_successive_args(1, 2, 3)" do
+    it 'passes when the block does not yield' do
+      expect { |b| _dont_yield(&b) }.not_to yield_successive_args(1, 2, 3)
+    end
+
+    it 'passes when the block yields the wrong number of times' do
+      expect { |b| [1, 2].each(&b) }.not_to yield_successive_args(1, 2, 3)
+    end
+
+    it 'passes when the block yields the wrong arguments' do
+      expect { |b| [1, 2, 4].each(&b) }.not_to yield_successive_args(1, 2, 3)
+    end
+
+    it 'fails when the block yields the given arguments' do
+      expect {
+        expect { |b| [1, 2, 3].each(&b) }.not_to yield_successive_args(1, 2, 3)
+      }.to fail_with(/expected given block not to yield successively/)
+    end
+
+    it 'fails if the expect block does not accept an argument' do
+      expect {
+        expect { }.not_to yield_successive_args(1, 2, 3)
+      }.to raise_error(/expect block must accept an argument/)
+    end
+
+    it 'raises an error if the expect block arg is not passed to a method as a block' do
+      expect {
+        expect { |b| }.not_to yield_successive_args(1, 2, 3)
+      }.to raise_error(/must pass the argument.*as a block/)
+    end
+  end
+
+  describe "expect {...}.to yield_successive_args(String, Fixnum)" do
+    it "passes if the block successively yields objects of the given types" do
+      expect { |b| ["string", 15].each(&b) }.to yield_successive_args(String, Fixnum)
+    end
+
+    it "passes if the block yields the given types" do
+      expect { |b| [String, Fixnum].each(&b) }.to yield_successive_args(String, Fixnum)
+    end
+
+    it "fails if the block yields objects of different types" do
+      expect {
+        expect { |b| [15, "string"].each(&b) }.to yield_successive_args(String, Fixnum)
+      }.to fail_with(/expected given block to yield successively with arguments/)
+    end
+  end
+end
+

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

@@ -0,0 +1,27 @@
+def add_to_load_path(path, prepend=false)
+  path = File.expand_path("../../#{path}/lib", __FILE__)
+  if prepend
+    $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
+  else
+    $LOAD_PATH << path unless $LOAD_PATH.include?(path)
+  end
+end
+
+require 'test/unit'
+
+add_to_load_path("rspec-expectations", :prepend)
+add_to_load_path("rspec-core")
+add_to_load_path("rspec-mocks")
+
+require 'rspec/expectations'
+require 'rspec/core'
+require 'rspec/mocks'
+
+Dir['./spec/support/**/*'].each {|f| require f}
+
+RSpec::configure do |config|
+  config.color_enabled = true
+  config.filter_run :focused => true
+  config.run_all_when_everything_filtered = true
+  config.order = :random
+end

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

@@ -0,0 +1,56 @@
+# various classes used by the specs
+module RSpec
+  module Expectations
+    module Helper
+      class CollectionWithSizeMethod
+        def initialize; @list = []; end
+        def size; @list.size; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionWithLengthMethod
+        def initialize; @list = []; end
+        def length; @list.size; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionWithCountMethod
+        def initialize; @list = []; end
+        def count; @list.count; end
+        def push(item); @list.push(item); end
+      end
+
+      class CollectionOwner
+        attr_reader :items_in_collection_with_size_method, :items_in_collection_with_length_method, :items_in_collection_with_count_method
+
+        def initialize
+          @items_in_collection_with_size_method = CollectionWithSizeMethod.new
+          @items_in_collection_with_length_method = CollectionWithLengthMethod.new
+          @items_in_collection_with_count_method = CollectionWithCountMethod.new
+        end
+
+        def add_to_collection_with_size_method(item)
+          @items_in_collection_with_size_method.push(item)
+        end
+
+      def add_to_collection_with_length_method(item)
+        @items_in_collection_with_length_method.push(item)
+      end
+
+      def add_to_collection_with_count_method(item)
+        @items_in_collection_with_count_method.push(item)
+      end
+
+        def items_for(arg)
+          return [1, 2, 3] if arg == 'a'
+          [1]
+        end
+
+        def items
+          @items_in_collection_with_size_method
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module InSubProcess
+  # Useful as a way to isolate a global change to a subprocess.
+  def in_sub_process
+    readme, writeme = IO.pipe
+
+    pid = Process.fork do
+      value = nil
+      begin
+        yield
+      rescue => e
+        value = e
+      end
+
+      writeme.write Marshal.dump(value)
+
+      readme.close
+      writeme.close
+      exit! # prevent at_exit hooks from running (e.g. minitest)
+    end
+
+    writeme.close
+    Process.waitpid(pid)
+
+    if exception = Marshal.load(readme.read)
+      raise exception
+    end
+
+    readme.close
+  end
+end
+

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

@@ -0,0 +1,22 @@
+RSpec::Matchers.define :include_method do |expected|
+  match do |actual|
+    actual.map { |m| m.to_s }.include?(expected.to_s)
+  end
+end
+
+module RSpec
+  module Matchers
+    def fail
+      raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
+
+    def fail_with(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, message)
+    end
+
+    def fail_matching(message)
+      raise_error(RSpec::Expectations::ExpectationNotMetError, /#{Regexp.escape(message)}/)
+    end
+  end
+end
+

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

@@ -0,0 +1,10 @@
+module RSpec
+  module Ruby
+    class << self
+      def version
+        RUBY_VERSION
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,13 @@
+shared_examples_for "an RSpec matcher" do |options|
+  let(:valid_value)   { options.fetch(:valid_value) }
+  let(:invalid_value) { options.fetch(:invalid_value) }
+
+  it 'matches a valid value when using #== so it can be composed' do
+    expect(matcher).to eq(valid_value)
+  end
+
+  it 'does not match an invalid value when using #== so it can be composed' do
+    expect(matcher).not_to eq(invalid_value)
+  end
+end
+