resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+require 'rubygems'
+
+begin
+  require 'spork'
+rescue LoadError
+  module Spork
+    def self.prefork
+      yield
+    end
+
+    def self.each_run
+      yield
+    end
+  end
+end
+
+Spork.prefork do
+  require 'rspec/autorun'
+  require 'autotest/rspec2'
+  require 'aruba/api'
+  require 'fakefs/spec_helpers'
+
+  Dir['./spec/support/**/*.rb'].map {|f| require f}
+
+  class NullObject
+    private
+    def method_missing(method, *args, &block)
+      # ignore
+    end
+  end
+
+  def sandboxed(&block)
+    @orig_config = RSpec.configuration
+    @orig_world  = RSpec.world
+    new_config = RSpec::Core::Configuration.new
+    new_world  = RSpec::Core::World.new(new_config)
+    RSpec.instance_variable_set(:@configuration, new_config)
+    RSpec.instance_variable_set(:@world, new_world)
+    object = Object.new
+    object.extend(RSpec::Core::SharedExampleGroup)
+
+    (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+      alias_method :orig_run, :run
+      def run(reporter=nil)
+        @orig_mock_space = RSpec::Mocks::space
+        RSpec::Mocks::space = RSpec::Mocks::Space.new
+        orig_run(reporter || NullObject.new)
+      ensure
+        RSpec::Mocks::space = @orig_mock_space
+      end
+    end
+
+    object.instance_eval(&block)
+  ensure
+    (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+      remove_method :run
+      alias_method :run, :orig_run
+      remove_method :orig_run
+    end
+
+    RSpec.instance_variable_set(:@configuration, @orig_config)
+    RSpec.instance_variable_set(:@world, @orig_world)
+  end
+
+  def in_editor?
+    ENV.has_key?('TM_MODE') || ENV.has_key?('EMACS') || ENV.has_key?('VIM')
+  end
+
+  RSpec.configure do |c|
+    # structural
+    c.alias_it_should_behave_like_to 'it_has_behavior'
+    c.around {|example| sandboxed { example.run }}
+    c.include Aruba::Api, :example_group => {
+      :file_path => /spec\/command_line/
+    }
+
+    # runtime options
+    c.treat_symbols_as_metadata_keys_with_true_values = true
+    c.color = !in_editor?
+    c.filter_run :focus
+    c.filter_run :foo
+    c.include FakeFS::SpecHelpers, :fakefs
+    c.run_all_when_everything_filtered = true
+    c.filter_run_excluding :ruby => lambda {|version|
+      case version.to_s
+      when "!jruby"
+        RUBY_ENGINE == "jruby"
+      when /^> (.*)/
+        !(RUBY_VERSION.to_s > $1)
+      else
+        !(RUBY_VERSION.to_s =~ /^#{version.to_s}/)
+      end
+    }
+  end
+end
+
+Spork.each_run do
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/support/config_options_helper.rb

@@ -0,0 +1,27 @@
+require 'fakefs/safe'
+
+module ConfigOptionsHelper
+  extend RSpec::SharedContext
+
+  before do
+    FakeFS.activate!
+    @orig_spec_opts = ENV["SPEC_OPTS"]
+    ENV.delete("SPEC_OPTS")
+  end
+
+  after do
+    FakeFS::FileSystem.clear
+    ENV["SPEC_OPTS"] = @orig_spec_opts
+    FakeFS.deactivate!
+  end
+
+  def config_options_object(*args)
+    coo = RSpec::Core::ConfigurationOptions.new(args)
+    coo.parse_options
+    coo
+  end
+
+  def parse_options(*args)
+    config_options_object(*args).options
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/support/matchers.rb

@@ -0,0 +1,65 @@
+RSpec::Matchers.define :map_specs do |specs|
+  match do |autotest|
+    @specs = specs
+    @autotest = prepare(autotest)
+    autotest.test_files_for(@file) == specs
+  end
+
+  chain :to do |file|
+    @file = file
+  end
+
+  failure_message_for_should do
+    "expected #{@autotest.class} to map #{@specs.inspect} to #{@file.inspect}\ngot #{@actual.inspect}"
+  end
+
+  def prepare(autotest)
+    find_order = @specs.dup << @file
+    autotest.instance_eval { @find_order = find_order }
+    autotest
+  end
+end
+
+RSpec::Matchers.define :fail_with do |exception_klass|
+  match do |example|
+    failure_reason(example, exception_klass).nil?
+  end
+
+  failure_message_for_should do |example|
+    "expected example to fail with a #{exception_klass} exception, but #{failure_reason(example, exception_klass)}"
+  end
+
+  def failure_reason(example, exception_klass)
+    result = example.metadata[:execution_result]
+    case
+      when example.metadata[:pending] then "was pending"
+      when result[:status] != 'failed' then result[:status]
+      when !result[:exception].is_a?(exception_klass) then "failed with a #{result[:exception].class}"
+      else nil
+    end
+  end
+end
+
+RSpec::Matchers.define :pass do
+  match do |example|
+    failure_reason(example).nil?
+  end
+
+  failure_message_for_should do |example|
+    "expected example to pass, but #{failure_reason(example)}"
+  end
+
+  def failure_reason(example)
+    result = example.metadata[:execution_result]
+    case
+      when example.metadata[:pending] then "was pending"
+      when result[:status] != 'passed' then result[:status]
+      else nil
+    end
+  end
+end
+
+RSpec::Matchers.module_eval do
+  alias_method :have_failed_with, :fail_with
+  alias_method :have_passed, :pass
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/support/shared_example_groups.rb

@@ -0,0 +1,41 @@
+shared_examples_for "metadata hash builder" do
+  context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to true" do
+    let(:hash) { metadata_hash(:foo, :bar, :bazz => 23) }
+
+    before(:each) do
+      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = true }
+    end
+
+    it 'treats symbols as metadata keys with a true value' do
+      hash[:foo].should be(true)
+      hash[:bar].should be(true)
+    end
+
+    it 'still processes hash values normally' do
+      hash[:bazz].should be(23)
+    end
+  end
+
+  context "when RSpec.configuration.treat_symbols_as_metadata_keys_with_true_values is set to false" do
+    let(:warning_receiver) { Kernel }
+
+    before(:each) do
+      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = false }
+      warning_receiver.stub(:warn)
+    end
+
+    it 'prints a deprecation warning about any symbols given as arguments' do
+      warning_receiver.should_receive(:warn).with(/In RSpec 3, these symbols will be treated as metadata keys/)
+      metadata_hash(:foo, :bar, :key => 'value')
+    end
+
+    it 'does not treat symbols as metadata keys' do
+      metadata_hash(:foo, :bar, :key => 'value').should_not include(:foo, :bar)
+    end
+
+    it 'does not print a warning if there are no symbol arguments' do
+      warning_receiver.should_not_receive(:warn)
+      metadata_hash(:foo => 23, :bar => 17)
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/spec/support/spec_files.rb

@@ -0,0 +1,44 @@
+shared_context "spec files" do
+  def failing_spec_filename
+    @failing_spec_filename ||= File.expand_path(File.dirname(__FILE__)) + "/_failing_spec.rb"
+  end
+
+  def passing_spec_filename
+    @passing_spec_filename ||= File.expand_path(File.dirname(__FILE__)) + "/_passing_spec.rb"
+  end
+
+  def create_passing_spec_file
+    File.open(passing_spec_filename, 'w') do |f|
+      f.write %q{
+        describe "passing spec" do
+          it "passes" do
+            1.should eq(1)
+          end
+        end
+      }
+    end
+  end
+
+  def create_failing_spec_file
+    File.open(failing_spec_filename, 'w') do |f|
+      f.write %q{
+        describe "failing spec" do
+          it "fails" do
+            1.should eq(2)
+          end
+        end
+      }
+    end
+  end
+
+  before(:all) do
+    create_passing_spec_file
+    create_failing_spec_file
+  end
+
+  after(:all) do
+    File.delete(passing_spec_filename)
+    File.delete(failing_spec_filename)
+  end
+
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.0/Changelog.md

@@ -0,0 +1,176 @@
+### 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.0/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.0/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.0/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).