resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.0/spec/rspec/matchers/throw_symbol_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+module RSpec::Matchers::BuiltIn
+  describe ThrowSymbol do
+    describe "with no args" do
+      before(:each) { @matcher = throw_symbol }
+
+      it "matches if any Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :sym }).should be_true
+      end
+      it "matches if any Symbol is thrown with an arg" do
+        @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+      end
+      it "does not match if no Symbol is thrown" do
+        @matcher.matches?(lambda{ }).should be_false
+      end
+      it "provides a failure message" do
+        @matcher.matches?(lambda{})
+        @matcher.failure_message_for_should.should == "expected a Symbol to be thrown, got nothing"
+      end
+      it "provides a negative failure message" do
+        @matcher.matches?(lambda{ throw :sym})
+        @matcher.failure_message_for_should_not.should == "expected no Symbol to be thrown, got :sym"
+      end
+    end
+
+    describe "with a symbol" do
+      before(:each) { @matcher = throw_symbol(:sym) }
+
+      it "matches if correct Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :sym }).should be_true
+      end
+      it "matches if correct Symbol is thrown with an arg" do
+        @matcher.matches?(lambda{ throw :sym, "argument" }).should be_true
+      end
+      it "does not match if no Symbol is thrown" do
+        @matcher.matches?(lambda{ }).should be_false
+      end
+      it "does not match if correct Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :other_sym }).should be_false
+      end
+      it "provides a failure message when no Symbol is thrown" do
+        @matcher.matches?(lambda{})
+        @matcher.failure_message_for_should.should == "expected :sym to be thrown, got nothing"
+      end
+      it "provides a failure message when wrong Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :other_sym })
+        @matcher.failure_message_for_should.should == "expected :sym to be thrown, got :other_sym"
+      end
+      it "provides a negative failure message" do
+        @matcher.matches?(lambda{ throw :sym })
+        @matcher.failure_message_for_should_not.should == "expected :sym not to be thrown, got :sym"
+      end
+      it "only matches NameErrors raised by uncaught throws" do
+        expect {
+          @matcher.matches?(lambda{ sym }).should be_false
+        }.to raise_error(NameError)
+      end
+    end
+
+    describe "with a symbol and an arg" do
+      before(:each) { @matcher = throw_symbol(:sym, "a") }
+
+      it "matches if correct Symbol and args are thrown" do
+        @matcher.matches?(lambda{ throw :sym, "a" }).should be_true
+      end
+      it "does not match if nothing is thrown" do
+        @matcher.matches?(lambda{ }).should be_false
+      end
+      it "does not match if other Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :other_sym, "a" }).should be_false
+      end
+      it "does not match if no arg is thrown" do
+        @matcher.matches?(lambda{ throw :sym }).should be_false
+      end
+      it "does not match if wrong arg is thrown" do
+        @matcher.matches?(lambda{ throw :sym, "b" }).should be_false
+      end
+      it "provides a failure message when no Symbol is thrown" do
+        @matcher.matches?(lambda{})
+        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got nothing]
+      end
+      it "provides a failure message when wrong Symbol is thrown" do
+        @matcher.matches?(lambda{ throw :other_sym })
+        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :other_sym]
+      end
+      it "provides a failure message when wrong arg is thrown" do
+        @matcher.matches?(lambda{ throw :sym, "b" })
+        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with "b"]
+      end
+      it "provides a failure message when no arg is thrown" do
+        @matcher.matches?(lambda{ throw :sym })
+        @matcher.failure_message_for_should.should == %q[expected :sym with "a" to be thrown, got :sym with no argument]
+      end
+      it "provides a negative failure message" do
+        @matcher.matches?(lambda{ throw :sym })
+        @matcher.failure_message_for_should_not.should == %q[expected :sym with "a" not to be thrown, got :sym with no argument]
+      end
+      it "only matches NameErrors raised by uncaught throws" do
+        expect {
+          @matcher.matches?(lambda{ sym }).should be_false
+        }.to raise_error(NameError)
+      end
+      it "raises other errors" do
+        expect {
+          @matcher.matches?(lambda { raise "Boom" })
+        }.to raise_error(/Boom/)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.0/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/ruby/1.8/gems/rspec-expectations-2.9.0/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/ruby/1.8/gems/rspec-expectations-2.9.0/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/ruby/1.8/gems/rspec-expectations-2.9.0/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/ruby/1.8/gems/rspec-expectations-2.9.1/Changelog.md

@@ -0,0 +1,187 @@
+### 2.9.1 / 2012-04-03
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.9.0...2.9.1)
+
+Bug fixes
+
+* Provide a helpful message if the diff between two objects is empty.
+* Fix bug diffing single strings with multiline strings.
+* Fix for error with using custom matchers inside other custom matchers
+  (mirasrael)
+* Fix using execution context methods in nested DSL matchers (mirasrael)
+
+### 2.9.0 / 2012-03-17
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.8.0...v2.9.0)
+
+Enhancements
+
+* Move built-in matcher classes to RSpec::Matchers::BuiltIn to reduce pollution
+  of RSpec::Matchers (which is included in every example).
+* Autoload files with matcher classes to improve load time.
+
+Bug fixes
+
+* Align `respond_to?` and `method_missing` in DSL-defined matchers.
+* Clear out user-defined instance variables between invocations of DSL-defined
+  matchers.
+* Dup the instance of a DSL generated matcher so its state is not changed by
+  subsequent invocations.
+* Treat expected args consistently across positive and negative expectations
+  (thanks to Ralf Kistner for the heads up)
+
+### 2.8.0 / 2012-01-04
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.8.0.rc2...v2.8.0)
+
+Enhancements
+
+* Better diff output for Hash (Philippe Creux)
+* Eliminate Ruby warnings (Olek Janiszewski)
+
+### 2.8.0.rc2 / 2011-12-19
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.8.0.rc1...v2.8.0.rc2)
+
+No changes for this release. Just releasing with the other rspec gems.
+
+### 2.8.0.rc1 / 2011-11-06
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.7.0...v2.8.0.rc1)
+
+Enhancements
+
+* Use classes for the built-in matchers (they're faster).
+* Eliminate Ruby warnings (Matijs van Zuijlen)
+
+### 2.7.0 / 2011-10-16
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.6.0...v2.7.0)
+
+Enhancements
+
+* `HaveMatcher` converts argument using `to_i` (Alex Bepple & Pat Maddox)
+* Improved failure message for the `have_xxx` matcher (Myron Marston)
+* `HaveMatcher` supports `count` (Matthew Bellantoni)
+* Change matcher dups `Enumerable` before the action, supporting custom
+  `Enumerable` types like `CollectionProxy` in Rails (David Chelimsky)
+
+Bug fixes
+
+* Fix typo in `have(n).xyz` documentation (Jean Boussier)
+* fix `safe_sort` for ruby 1.9.2 (`Kernel` now defines `<=>` for Object) (Peter
+  van Hardenberg)
+
+### 2.6.0 / 2011-05-12
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.5.0...v2.6.0)
+
+Enhancements
+
+* `change` matcher accepts regexps (Robert Davis)
+* better descriptions for `have_xxx` matchers (Magnus Bergmark)
+* `range.should cover(*values)` (Anders Furseth)
+
+Bug fixes
+
+* Removed non-ascii characters that were choking rcov (Geoffrey Byers)
+* change matcher dups arrays and hashes so their before/after states can be
+  compared correctly.
+* Fix the order of inclusion of RSpec::Matchers in Test::Unit::TestCase and
+  MiniTest::Unit::TestCase to prevent a SystemStackError (Myron Marston)
+
+### 2.5.0 / 2011-02-05
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.4.0...v2.5.0)
+
+Enhancements
+
+* `should exist` works with `exist?` or `exists?` (Myron Marston)
+* `expect { ... }.not_to do_something` (in addition to `to_not`)
+
+Documentation
+
+* improved docs for raise_error matcher (James Almond)
+
+### 2.4.0 / 2011-01-02
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.3.0...v2.4.0)
+
+No functional changes in this release, which was made to align with the
+rspec-core-2.4.0 release.
+
+Enhancements
+
+* improved RDoc for change matcher (Jo Liss)
+
+### 2.3.0 / 2010-12-12
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.2.1...v2.3.0)
+
+Enhancements
+
+* diff strings when include matcher fails (Mike Sassak)
+
+### 2.2.0 / 2010-11-28
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.1.0...v2.2.0)
+
+### 2.1.0 / 2010-11-07
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.1...v2.1.0)
+
+Enhancements
+
+* `be_within(delta).of(expected)` matcher (Myron Marston)
+* Lots of new Cucumber features (Myron Marston)
+* Raise error if you try `should != expected` on Ruby-1.9 (Myron Marston)
+* Improved failure messages from `throw_symbol` (Myron Marston)
+
+Bug fixes
+
+* Eliminate hard dependency on `RSpec::Core` (Myron Marston)
+* `have_matcher` - use pluralize only when ActiveSupport inflections are indeed
+  defined (Josep M Bach)
+* throw_symbol matcher no longer swallows exceptions (Myron Marston)
+* fix matcher chaining to avoid name collisions (Myron Marston)
+
+### 2.0.0 / 2010-10-10
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.rc...v2.0.0)
+
+Enhancements
+
+* Add match_for_should_not method to matcher DSL (Myron Marston)
+
+Bug fixes
+
+* `respond_to` matcher works correctly with `should_not` with multiple methods
+  (Myron Marston)
+* `include` matcher works correctly with `should_not` with multiple values
+  (Myron Marston)
+
+### 2.0.0.rc / 2010-10-05
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.22...v2.0.0.rc)
+
+Enhancements
+
+* `require 'rspec/expectations'` in a T::U or MiniUnit suite (Josep M. Bach)
+
+Bug fixes
+
+* change by 0 passes/fails correctly (Len Smith)
+* Add description to satisfy matcher
+
+### 2.0.0.beta.22 / 2010-09-12
+
+[full changelog](http://github.com/rspec/rspec-expectations/compare/v2.0.0.beta.20...v2.0.0.beta.22)
+
+Enhancements
+
+* diffing improvements
+    * diff multiline strings
+    * don't diff single line strings
+    * don't diff numbers (silly)
+    * diff regexp + multiline string
+
+Bug fixes
+    * `should[_not]` change now handles boolean values correctly

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/License.txt

@@ -0,0 +1,23 @@
+(The MIT License)
+
+Copyright (c) 2006 David Chelimsky, The RSpec Development Team
+Copyright (c) 2005 Steven Baker
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/README.md

@@ -0,0 +1,147 @@
+# RSpec Expectations
+
+RSpec::Expectations lets you express expected outcomes on an object in an
+example.
+
+    account.balance.should eq(Money.new(37.42, :USD))
+
+## Install
+
+If you want to use rspec-expectations with rspec, just install the rspec gem
+and RubyGems will also install rspec-expectations for you (along with
+rspec-core and rspec-mocks):
+
+    gem install rspec
+
+If you want to use rspec-expectations with another tool, like Test::Unit,
+Minitest, or Cucumber, you can install it directly:
+
+    gem install rspec-expectations
+
+## Basic usage
+
+Here's an example using rspec-core:
+
+```ruby
+describe Order do
+  it "sums the prices of the items in its line items" do
+    order = Order.new
+    order.add_entry(LineItem.new(:item => Item.new(
+      :price => Money.new(1.11, :USD)
+    )))
+    order.add_entry(LineItem.new(:item => Item.new(
+      :price => Money.new(2.22, :USD),
+      :quantity => 2
+    )))
+    order.total.should eq(Money.new(5.55, :USD))
+  end
+end
+```
+
+The `describe` and `it` methods come from rspec-core.  The `Order`, `LineItem`,
+and `Item` classes would be from _your_ code. The last line of the example
+expresses an expected outcome. If `order.total == Money.new(5.55, :USD)`, then
+the example passes. If not, it fails with a message like:
+
+    expected: #<Money @value=5.55 @currency=:USD>
+         got: #<Money @value=1.11 @currency=:USD>
+
+## Built-in matchers
+
+### Equivalence
+
+```ruby
+actual.should eq(expected)  # passes if actual == expected
+actual.should == expected   # passes if actual == expected
+actual.should eql(expected) # passes if actual.eql?(expected)
+```
+
+### Identity
+
+```ruby
+actual.should be(expected)    # passes if actual.equal?(expected)
+actual.should equal(expected) # passes if actual.equal?(expected)
+```
+    
+### Comparisons
+
+```ruby
+actual.should be >  expected
+actual.should be >= expected
+actual.should be <= expected
+actual.should be <  expected
+actual.should be_within(delta).of(expected)
+```
+
+### Regular expressions
+
+```ruby
+actual.should =~ /expression/
+actual.should match(/expression/)
+```
+
+### Types/classes
+
+```ruby
+actual.should be_an_instance_of(expected)
+actual.should be_a_kind_of(expected)
+```
+
+### Truthiness
+
+```ruby
+actual.should be_true  # passes if actual is truthy (not nil or false)
+actual.should be_false # passes if actual is falsy (nil or false)
+actual.should be_nil   # passes if actual is nil
+```
+
+### Expecting errors
+
+```ruby
+expect { ... }.to raise_error
+expect { ... }.to raise_error(ErrorClass)
+expect { ... }.to raise_error("message")
+expect { ... }.to raise_error(ErrorClass, "message")
+```
+
+### Expecting throws
+
+```ruby
+expect { ... }.to throw_symbol
+expect { ... }.to throw_symbol(:symbol)
+expect { ... }.to throw_symbol(:symbol, 'value')
+```
+
+### Predicate matchers
+
+```ruby
+actual.should be_xxx         # passes if actual.xxx?
+actual.should have_xxx(:arg) # passes if actual.has_xxx?(:arg)
+```
+
+### Ranges (Ruby >= 1.9 only)
+
+```ruby
+(1..10).should cover(3)
+```
+
+### Collection membership
+
+```ruby
+actual.should include(expected)
+```
+
+#### Examples
+
+```ruby
+[1,2,3].should include(1)
+[1,2,3].should include(1, 2)
+{:a => 'b'}.should include(:a => 'b')
+"this string".should include("is str")
+```
+
+## Also see
+
+* [http://github.com/rspec/rspec](http://github.com/rspec/rspec)
+* [http://github.com/rspec/rspec-core](http://github.com/rspec/rspec-core)
+* [http://github.com/rspec/rspec-mocks](http://github.com/rspec/rspec-mocks)

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/features/README.markdown

@@ -0,0 +1,49 @@
+rspec-expectations is used to define expected outcomes.
+
+    describe Account do
+      it "has a balance of zero when first created" do
+        Account.new.balance.should eq(Money.new(0))
+      end
+    end
+
+## Basic structure
+
+The basic structure of an rspec expectation is:
+
+    actual.should matcher(expected)
+    actual.should_not matcher(expected)
+
+## `should` and `should_not`
+
+`rspec-expectations` adds `should` and `should_not` to every object in
+the system. These methods each accept a matcher as an argument. This allows
+each matcher to work in a positive or negative mode:
+
+    5.should eq(5)
+    5.should_not eq(4)
+
+## What is a matcher?
+
+A Matcher is any object that responds to the following methods:
+
+    matches?(actual)
+    failure_message_for_should
+
+These methods are also part of the matcher protocol, but are optional:
+
+    does_not_match?(actual)
+    failure_message_for_should_not
+    description
+
+RSpec ships with a number of built-in matchers and a DSL for writing custom
+matchers.
+
+## Issues
+
+The documentation for rspec-expectations is a work in progress. We'll be adding
+Cucumber features over time, and clarifying existing ones.  If you have
+specific features you'd like to see added, find the existing documentation
+incomplete or confusing, or, better yet, wish to write a missing Cucumber
+feature yourself, please [submit an
+issue](http://github.com/rspec/rspec-expectations/issues) or a [pull
+request](http://github.com/rspec/rspec-expectations).

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/features/Upgrade.md

@@ -0,0 +1,53 @@
+# Upgrade to rspec-expectations-2.0
+
+## What's new
+
+### New `eq` matcher.
+
+`RSpec::Matchers` now offers you two approaches to differentiating between
+object identity. You can use the rspec-1 approach:
+
+    actual.should == expected     # object equality
+    actual.should equal(expected) # object identity
+
+... or, if you prefer:
+
+    actual.should eq(expected) # object equality
+    actual.should be(expected) # object identity
+
+## What's been removed
+
+### simple_matcher
+
+Use RSpec::Matchers.define instead. For example, if you had:
+
+    def eat_cheese
+      simple_matcher("eat cheese") do |actual|
+        actual.eat?(:cheese)
+      end
+    end
+
+Change it to:
+
+    RSpec::Matchers.define :eat_cheese do
+      match do |actual|
+        actual.eat?(:cheese)
+      end
+    end
+
+### wrap_expectation
+
+Use RSpec::Matchers.define instead.
+
+    RSpec::Matchers.define :eat_cheese do
+      match do |actual|
+        actual.should eat?(:cheese)
+      end
+    end
+
+    RSpec::Matchers.define :eat_cheese do
+      include MyCheesyAssertions
+      match_unless_raises Test::Unit::AssertionFailedError do |actual|
+        assert_eats_chesse actual
+      end
+    end