resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/differ.rb

@@ -0,0 +1,81 @@
+require 'diff/lcs'
+require 'diff/lcs/hunk'
+require 'pp'
+
+module RSpec
+  module Expectations
+    class Differ
+      # This is snagged from diff/lcs/ldiff.rb (which is a commandline tool)
+      def diff_as_string(data_new, data_old)
+        data_old = data_old.split(/\n/).map! { |e| e.chomp }
+        data_new = data_new.split(/\n/).map! { |e| e.chomp }
+        diffs = Diff::LCS.diff(data_old, data_new)
+        output = ""
+        return output if diffs.empty?
+        oldhunk = hunk = nil
+        file_length_difference = 0
+        diffs.each do |piece|
+          begin
+            hunk = Diff::LCS::Hunk.new(
+              data_old, data_new, piece, context_lines, file_length_difference
+            )
+            file_length_difference = hunk.file_length_difference
+            next unless oldhunk
+            # Hunks may overlap, which is why we need to be careful when our
+            # diff includes lines of context. Otherwise, we might print
+            # redundant lines.
+            if (context_lines > 0) and hunk.overlaps?(oldhunk)
+              hunk.unshift(oldhunk)
+            else
+              output << oldhunk.diff(format)
+            end
+          ensure
+            oldhunk = hunk
+            output << "\n"
+          end
+        end
+        #Handle the last remaining hunk
+        output << oldhunk.diff(format) << "\n"
+      end
+
+      def diff_as_object(actual, expected)
+        actual_as_string = object_to_string(actual)
+        expected_as_string = object_to_string(expected)
+        diff = diff_as_string(actual_as_string, expected_as_string)
+
+        if diff.empty?
+          "#{actual}.==(#{expected}) returned false even though the diff " \
+          "between #{actual} and #{expected} is empty. Check the " \
+          "implementation of #{actual}.==."
+        else
+          diff
+        end
+      end
+
+    protected
+
+      def format
+        :unified
+      end
+
+      def context_lines
+        3
+      end
+
+      def object_to_string(object)
+        case object
+        when Hash
+          object.keys.sort_by { |k| k.to_s }.map do |k|
+            %(#{PP.singleline_pp(k, "")} => #{PP.singleline_pp(object[k], "")})
+          end.join(",\n")
+        when String
+          object =~ /\n/ ? object : object.inspect
+        else
+          PP.pp(object,"")
+        end
+      end
+    end
+
+  end
+end
+

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/errors.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Expectations
+    if defined?(Test::Unit::AssertionFailedError)
+      class ExpectationNotMetError < Test::Unit::AssertionFailedError; end
+    else
+      class ExpectationNotMetError < ::StandardError; end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/extensions/array.rb

@@ -0,0 +1,9 @@
+# @private
+class Array
+  unless public_instance_methods.map {|m| m.to_s}.include?('none?')
+    # Supports +none?+ on early patch levels of Ruby 1.8.6
+    def none?(&block)
+      !any?(&block)
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/extensions/kernel.rb

@@ -0,0 +1,26 @@
+module Kernel
+  # Passes if +matcher+ returns true.  Available on every +Object+.
+  # @example
+  #   actual.should eq(expected)
+  #   actual.should be > 4
+  # @param [Matcher]
+  #   matcher
+  # @param [String] message optional message to display when the expectation fails
+  # @return [Boolean] true if the expectation succeeds (else raises)
+  # @see RSpec::Matchers
+  def should(matcher=nil, message=nil, &block)
+    RSpec::Expectations::PositiveExpectationHandler.handle_matcher(self, matcher, message, &block)
+  end
+
+  # Passes if +matcher+ returns false.  Available on every +Object+.
+  # @example
+  #   actual.should_not eq(expected)
+  # @param [Matcher]
+  #   matcher
+  # @param [String] message optional message to display when the expectation fails
+  # @return [Boolean] false if the negative expectation succeeds (else raises)
+  # @see RSpec::Matchers
+  def should_not(matcher=nil, message=nil, &block)
+    RSpec::Expectations::NegativeExpectationHandler.handle_matcher(self, matcher, message, &block)
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/extensions/object.rb

@@ -0,0 +1,39 @@
+module RSpec
+  module Expectations
+    module DeprecatedConstants
+      # Displays deprecation warning when it captures Rspec and Spec. Otherwise
+      # delegates to super.
+      def const_missing(name)
+        case name
+        when :Rspec, :Spec
+          RSpec.warn_deprecation <<-WARNING
+*****************************************************************
+DEPRECATION WARNING: you are using a deprecated constant that will
+be removed from a future version of RSpec.
+
+#{caller(0)[2]}
+
+* #{name} is deprecated.
+* RSpec is the new top-level module in RSpec-2
+***************************************************************
+WARNING
+          RSpec
+        else
+          begin
+            super
+          rescue Exception => e
+            e.backtrace.reject! {|l| l =~ Regexp.compile(__FILE__) }
+            raise e
+          end
+        end
+      end
+    end
+
+    # @deprecated (no replacement)
+    def differ=(ignore)
+      RSpec.deprecate("RSpec::Expectations.differ=(differ)", "nothing at all (diffing is now automatic and no longer configurable)")
+    end
+  end
+end
+
+extend RSpec::Expectations::DeprecatedConstants

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/extensions.rb

@@ -0,0 +1,3 @@
+require 'rspec/expectations/extensions/kernel'
+require 'rspec/expectations/extensions/array'
+require 'rspec/expectations/extensions/object'

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/fail_with.rb

@@ -0,0 +1,55 @@
+module RSpec
+  module Expectations
+    class << self
+      # @private
+      def differ
+        @differ ||= Differ.new
+      end
+
+      # Raises an RSpec::Expectations::ExpectationNotMetError with message.
+      # @param [String] message
+      # @param [Object] expected
+      # @param [Object] actual
+      #
+      # Adds a diff to the failure message when `expected` and `actual` are
+      # both present.
+      def fail_with(message, expected=nil, actual=nil)
+        if !message
+          raise ArgumentError, "Failure message is nil. Does your matcher define the " +
+                               "appropriate failure_message_for_* method to return a string?"
+        end
+
+        if actual && expected
+          if all_strings?(actual, expected)
+            if any_multiline_strings?(actual, expected)
+              expected = expected.join(',') if Array === expected
+              message << "\nDiff:" << differ.diff_as_string(actual, expected)
+            end
+          elsif no_procs?(actual, expected) && no_numbers?(actual, expected)
+            message << "\nDiff:" << differ.diff_as_object(actual, expected)
+          end
+        end
+
+        raise(RSpec::Expectations::ExpectationNotMetError.new(message))
+      end
+
+    private
+
+      def no_procs?(*args)
+        args.flatten.none? {|a| Proc === a}
+      end
+
+      def all_strings?(*args)
+        args.flatten.all? {|a| String === a}
+      end
+
+      def any_multiline_strings?(*args)
+        all_strings?(*args) && args.any? {|a| a =~ /\n/}
+      end
+
+      def no_numbers?(*args)
+        args.flatten.none? {|a| Numeric === a}
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/handler.rb

@@ -0,0 +1,48 @@
+module RSpec
+  module Expectations
+    class PositiveExpectationHandler        
+      def self.handle_matcher(actual, matcher, message=nil, &block)
+        ::RSpec::Matchers.last_should = :should
+        ::RSpec::Matchers.last_matcher = matcher
+        return ::RSpec::Matchers::BuiltIn::PositiveOperatorMatcher.new(actual) if matcher.nil?
+
+        match = matcher.matches?(actual, &block)
+        return match if match
+        
+        message ||= matcher.respond_to?(:failure_message_for_should) ?
+                    matcher.failure_message_for_should :
+                    matcher.failure_message
+        
+        if matcher.respond_to?(:diffable?) && matcher.diffable?
+          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+        else
+          ::RSpec::Expectations.fail_with message
+        end
+      end
+    end
+
+    class NegativeExpectationHandler
+      def self.handle_matcher(actual, matcher, message=nil, &block)
+        ::RSpec::Matchers.last_should = :should_not
+        ::RSpec::Matchers.last_matcher = matcher
+        return ::RSpec::Matchers::BuiltIn::NegativeOperatorMatcher.new(actual) if matcher.nil?
+        
+        match = matcher.respond_to?(:does_not_match?) ?
+                !matcher.does_not_match?(actual, &block) :
+                matcher.matches?(actual, &block)
+        return match unless match
+        
+        message ||= matcher.respond_to?(:failure_message_for_should_not) ?
+                    matcher.failure_message_for_should_not :
+                    matcher.negative_failure_message
+
+        if matcher.respond_to?(:diffable?) && matcher.diffable?
+          ::RSpec::Expectations.fail_with message, matcher.expected, matcher.actual
+        else
+          ::RSpec::Expectations.fail_with message
+        end
+      end
+    end
+  end
+end
+

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations/version.rb

@@ -0,0 +1,8 @@
+module RSpec
+  module Expectations
+    # @private
+    module Version
+      STRING = '2.9.1'
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/expectations.rb

@@ -0,0 +1,45 @@
+require 'rspec/expectations/extensions'
+require 'rspec/matchers'
+require 'rspec/expectations/fail_with'
+require 'rspec/expectations/errors'
+require 'rspec/expectations/deprecation'
+require 'rspec/expectations/handler'
+require 'rspec/expectations/version'
+require 'rspec/expectations/differ'
+
+module RSpec
+  # RSpec::Expectations adds two instance methods to every object:
+  #
+  #     should(matcher=nil)
+  #     should_not(matcher=nil)
+  #
+  # Both methods take an optional matcher object (See
+  # [RSpec::Matchers](../RSpec/Matchers)).  When `should` is invoked with a
+  # matcher, it turns around and calls `matcher.matches?(self)`.  For example,
+  # in the expression:
+  #
+  #     order.total.should eq(Money.new(5.55, :USD))
+  #
+  # the `should` method invokes the equivalent of `eq.matches?(order.total)`. If
+  # `matches?` returns true, the expectation is met and execution continues. If
+  # `false`, then the spec fails with the message returned by
+  # `eq.failure_message_for_should`.
+  #
+  # Given the expression:
+  #
+  #     order.entries.should_not include(entry)
+  #
+  # the `should_not` method invokes the equivalent of
+  # `include.matches?(order.entries)`, but it interprets `false` as success, and
+  # `true` as a failure, using the message generated by
+  # `eq.failure_message_for_should_not`.
+  #
+  # rspec-expectations ships with a standard set of useful matchers, and writing
+  # your own matchers is quite simple. 
+  #
+  # See [RSpec::Matchers](../RSpec/Matchers) for more information about the
+  # built-in matchers that ship with rspec-expectations, and how to write your
+  # own custom matchers.
+  module Expectations
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/matchers/be_close.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Matchers
+    # @deprecated use +be_within+ instead.
+    def be_close(expected, delta)
+      RSpec.deprecate("be_close(#{expected}, #{delta})", "be_within(#{delta}).of(#{expected})")
+      be_within(delta).of(expected)
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/matchers/block_aliases.rb

@@ -0,0 +1,21 @@
+require 'rspec/expectations/extensions/kernel'
+module RSpec
+  module Matchers
+    module BlockAliases
+      alias_method :to,     :should
+      alias_method :to_not, :should_not
+      alias_method :not_to, :should_not
+    end
+
+    # Extends the submitted block with aliases to and to_not
+    # for should and should_not.
+    #
+    # @example
+    #   expect { this_block }.to change{this.expression}.from(old_value).to(new_value)
+    #   expect { this_block }.to raise_error
+    def expect(&block)
+      block.extend BlockAliases
+    end
+  end
+end
+

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/matchers/built_in/base_matcher.rb

@@ -0,0 +1,58 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      # @api private
+      #
+      # Used _internally_ as a base class for matchers that ship with
+      # rspec-expectations.
+      #
+      # ### Warning:
+      #
+      # This class is for internal use, and subject to change without notice.  We
+      # strongly recommend that you do not base your custom matchers on this
+      # class. If/when this changes, we will announce it and remove this warning.
+      module BaseMatcher
+        include RSpec::Matchers::Pretty
+
+        attr_reader :actual, :expected, :rescued_exception
+
+        def initialize(expected=nil)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @actual = actual
+        end
+
+        def match_unless_raises(exception=Exception)
+          begin
+            yield
+            true
+          rescue exception => @rescued_exception
+            false
+          end
+        end
+
+        def failure_message_for_should
+          "expected #{actual.inspect} to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{actual.inspect} not to #{name_to_sentence}#{expected_to_sentence}"
+        end
+
+        def description
+          expected ? "#{name_to_sentence} #{expected.inspect}" : name_to_sentence
+        end
+
+        def diffable?
+          false
+        end
+
+        def ==(other)
+          matches?(other)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/matchers/built_in/be.rb

@@ -0,0 +1,183 @@
+require 'rspec/matchers/dsl'
+
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeTrue
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual)
+        end
+      end
+
+      class BeFalse
+        include BaseMatcher
+
+        def matches?(actual)
+          !super(actual)
+        end
+      end
+
+      class BeNil
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual).nil?
+        end
+
+        def failure_message_for_should
+          "expected: nil\n     got: #{actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected: not nil\n     got: nil"
+        end
+      end
+
+      class Be
+        include RSpec::Matchers::Pretty
+
+        def initialize(*args, &block)
+          @args = args
+        end
+
+        def matches?(actual)
+          @actual = actual
+          !!@actual
+        end
+
+        def failure_message_for_should
+          "expected #{@actual.inspect} to evaluate to true"
+        end
+
+        def failure_message_for_should_not
+          "expected #{@actual.inspect} to evaluate to false"
+        end
+
+        def description
+          "be"
+        end
+
+        [:==, :<, :<=, :>=, :>, :===].each do |operator|
+          define_method operator do |operand|
+            BeComparedTo.new(operand, operator)
+          end
+        end
+
+        private
+
+        def args_to_s
+          @args.empty? ? "" : parenthesize(inspected_args.join(', '))
+        end
+
+        def parenthesize(string)
+          "(#{string})"
+        end
+
+        def inspected_args
+          @args.collect{|a| a.inspect}
+        end
+
+        def expected_to_sentence
+          split_words(@expected)
+        end
+
+        def args_to_sentence
+          to_sentence(@args)
+        end
+      end
+
+      class BeComparedTo < Be
+        def initialize(operand, operator)
+          @expected, @operator = operand, operator
+            @args = []
+        end
+
+        def matches?(actual)
+          @actual = actual
+          @actual.__send__(@operator, @expected)
+        end
+
+        def failure_message_for_should
+          "expected: #{@operator} #{@expected.inspect}\n     got: #{@operator.to_s.gsub(/./, ' ')} #{@actual.inspect}"
+        end
+
+        def failure_message_for_should_not
+          message = <<-MESSAGE
+'should_not be #{@operator} #{@expected}' not only FAILED,
+it is a bit confusing.
+          MESSAGE
+
+          raise message << ([:===,:==].include?(@operator) ?
+                            "It might be more clearly expressed without the \"be\"?" :
+                            "It might be more clearly expressed in the positive?")
+        end
+
+        def description
+          "be #{@operator} #{expected_to_sentence}#{args_to_sentence}"
+        end
+      end
+
+      class BePredicate < Be
+        def initialize(*args, &block)
+          @expected = parse_expected(args.shift)
+          @args = args
+          @block = block
+        end
+
+        def matches?(actual)
+          @actual = actual
+          begin
+            return @result = actual.__send__(predicate, *@args, &@block)
+          rescue NameError => predicate_missing_error
+            "this needs to be here or rcov will not count this branch even though it's executed in a code example"
+          end
+
+          begin
+            return @result = actual.__send__(present_tense_predicate, *@args, &@block)
+          rescue NameError
+            raise predicate_missing_error
+          end
+        end
+
+        def failure_message_for_should
+          "expected #{predicate}#{args_to_s} to return true, got #{@result.inspect}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{predicate}#{args_to_s} to return false, got #{@result.inspect}"
+        end
+
+        def description
+          "#{prefix_to_sentence}#{expected_to_sentence}#{args_to_sentence}"
+        end
+
+        private
+
+        def predicate
+          "#{@expected}?".to_sym
+        end
+
+        def present_tense_predicate
+          "#{@expected}s?".to_sym
+        end
+
+        def parse_expected(expected)
+          @prefix, expected = prefix_and_expected(expected)
+          expected
+        end
+
+        def prefix_and_expected(symbol)
+          symbol.to_s =~ /^(be_(an?_)?)(.*)/
+          return $1, $3
+        end
+
+        def prefix_to_sentence
+          split_words(@prefix)
+        end
+      end
+    end
+
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/matchers/built_in/be_instance_of.rb

@@ -0,0 +1,13 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeAnInstanceOf
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual).instance_of?(expected)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/matchers/built_in/be_kind_of.rb

@@ -0,0 +1,13 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeAKindOf
+        include BaseMatcher
+
+        def matches?(actual)
+          super(actual).kind_of?(expected)
+        end
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-expectations-2.9.1/lib/rspec/matchers/built_in/be_within.rb

@@ -0,0 +1,39 @@
+module RSpec
+  module Matchers
+    module BuiltIn
+      class BeWithin
+        include BaseMatcher
+
+        attr_reader :delta
+
+        def initialize(delta)
+          @delta = delta
+        end
+
+        def matches?(actual)
+          unless defined?(@expected)
+            raise ArgumentError.new("You must set an expected value using #of: be_within(#{delta}).of(expected_value)")
+          end
+          (super(actual) - expected).abs < delta
+        end
+
+        def of(expected)
+          @expected = expected
+          self
+        end
+
+        def failure_message_for_should
+          "expected #{actual} to #{description}"
+        end
+
+        def failure_message_for_should_not
+          "expected #{actual} not to #{description}"
+        end
+
+        def description
+          "be within #{delta} of #{expected}"
+        end
+      end
+    end
+  end
+end