resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/lib/rspec/core/subject.rb

@@ -0,0 +1,183 @@
+module RSpec
+  module Core
+    module Subject
+      module ExampleMethods
+
+        # Returns the subject defined by the example group. The subject block is
+        # only executed once per example, the result of which is cached and
+        # returned by any subsequent calls to +subject+.
+        #
+        # If a class is passed to +describe+ and no subject is explicitly
+        # declared in the example group, then +subject+ will return a new
+        # instance of that class.
+        #
+        # @example
+        #
+        #   # explicit subject defined by the subject method
+        #   describe Person do
+        #     subject { Person.new(:birthdate => 19.years.ago) }
+        #     it "should be eligible to vote" do
+        #       subject.should be_eligible_to_vote
+        #     end
+        #   end
+        #
+        #   # implicit subject => { Person.new }
+        #   describe Person do
+        #     it "should be eligible to vote" do
+        #       subject.should be_eligible_to_vote
+        #     end
+        #   end
+        def subject
+          if defined?(@original_subject)
+            @original_subject
+          else
+            @original_subject = instance_eval(&self.class.subject)
+          end
+        end
+
+        begin
+          require 'rspec/expectations/extensions/kernel'
+          alias_method :__should_for_example_group__,     :should
+          alias_method :__should_not_for_example_group__, :should_not
+
+          # When +should+ is called with no explicit receiver, the call is
+          # delegated to the object returned by +subject+. Combined with
+          # an implicit subject (see +subject+), this supports very concise
+          # expressions.
+          #
+          # @example
+          #
+          #   describe Person do
+          #     it { should be_eligible_to_vote }
+          #   end
+          def should(matcher=nil, message=nil)
+            self == subject ? self.__should_for_example_group__(matcher) : subject.should(matcher,message)
+          end
+
+          # Just like +should+, +should_not+ delegates to the subject (implicit or
+          # explicit) of the example group.
+          #
+          # @example
+          #
+          #   describe Person do
+          #     it { should_not be_eligible_to_vote }
+          #   end
+          def should_not(matcher=nil, message=nil)
+            self == subject ? self.__should_not_for_example_group__(matcher) : subject.should_not(matcher,message)
+          end
+        rescue LoadError
+        end
+
+        def _attribute_chain(attribute)
+          attribute.to_s.split('.')
+        end
+
+        def _nested_attribute(subject, attribute)
+          _attribute_chain(attribute).inject(subject) do |subject, attr|
+            subject.send(attr)
+          end
+        end
+      end
+
+      module ExampleGroupMethods
+        # Creates a nested example group named by the submitted +attribute+,
+        # and then generates an example using the submitted block.
+        #
+        #   # This ...
+        #   describe Array do
+        #     its(:size) { should eq(0) }
+        #   end
+        #
+        #   # ... generates the same runtime structure as this:
+        #   describe Array do
+        #     describe "size" do
+        #       it "should eq(0)" do
+        #         subject.size.should eq(0)
+        #       end
+        #     end
+        #   end
+        #
+        # The attribute can be a +Symbol+ or a +String+. Given a +String+
+        # with dots, the result is as though you concatenated that +String+
+        # onto the subject in an expression.
+        #
+        #   describe Person do
+        #     subject do
+        #       Person.new.tap do |person|
+        #         person.phone_numbers << "555-1212"
+        #       end
+        #     end
+        #
+        #     its("phone_numbers.first") { should eq("555-1212") }
+        #   end
+        #
+        # When the subject is a +Hash+, you can refer to the Hash keys by
+        # specifying a +Symbol+ or +String+ in an array.
+        #
+        #   describe "a configuration Hash" do
+        #     subject do
+        #       { :max_users => 3,
+        #         'admin' => :all_permissions }
+        #     end
+        #
+        #     its([:max_users]) { should eq(3) }
+        #     its(['admin']) { should eq(:all_permissions) }
+        #
+        #     # You can still access to its regular methods this way:
+        #     its(:keys) { should include(:max_users) }
+        #     its(:count) { should eq(2) }
+        #   end
+        def its(attribute, &block)
+          describe(attribute) do
+            example do
+              self.class.class_eval do
+                define_method(:subject) do
+                  if defined?(@_subject)
+                    @_subject
+                  else
+                    @_subject = Array === attribute ? super()[*attribute] : _nested_attribute(super(), attribute)
+                  end
+                end
+              end
+              instance_eval(&block)
+            end
+          end
+        end
+
+        # Defines an explicit subject for an example group which can then be the
+        # implicit receiver (through delegation) of calls to +should+.
+        #
+        # @example
+        #
+        #   describe CheckingAccount, "with $50" do
+        #     subject { CheckingAccount.new(:amount => 50, :currency => :USD) }
+        #     it { should have_a_balance_of(50, :USD) }
+        #     it { should_not be_overdrawn }
+        #   end
+        #
+        # See +ExampleMethods#should+ for more information about this approach.
+        def subject(&block)
+          block ? @explicit_subject_block = block : explicit_subject || implicit_subject
+        end
+
+        attr_reader :explicit_subject_block
+
+        private
+
+        def explicit_subject
+          group = self
+          while group.respond_to?(:explicit_subject_block)
+            return group.explicit_subject_block if group.explicit_subject_block
+            group = group.superclass
+          end
+        end
+
+        def implicit_subject
+          described = described_class || description
+          Class === described ? proc { described.new } : proc { described }
+        end
+      end
+
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/lib/rspec/core/version.rb

@@ -0,0 +1,7 @@
+module RSpec
+  module Core
+    module Version
+      STRING = '2.9.0'
+    end
+  end
+end

data/vendor/bundle/ruby/1.8/gems/rspec-core-2.9.0/lib/rspec/core/world.rb

@@ -0,0 +1,132 @@
+module RSpec
+  module Core
+    class World
+
+      include RSpec::Core::Hooks
+
+      attr_reader :example_groups, :shared_example_groups, :filtered_examples
+      attr_accessor :wants_to_quit
+
+      def initialize(configuration=RSpec.configuration)
+        @configuration = configuration
+        @example_groups = [].extend(Extensions::Ordered)
+        @shared_example_groups = {}
+        @filtered_examples = Hash.new { |hash,group|
+          hash[group] = begin
+            examples = group.examples.dup
+            examples = filter_manager.prune(examples)
+            examples.uniq
+            examples.extend(Extensions::Ordered)
+          end
+        }
+      end
+
+      def reset
+        example_groups.clear
+        shared_example_groups.clear
+      end
+
+      def filter_manager
+        @configuration.filter_manager
+      end
+
+      def register(example_group)
+        example_groups << example_group
+        example_group
+      end
+
+      def inclusion_filter
+        @configuration.inclusion_filter
+      end
+
+      def exclusion_filter
+        @configuration.exclusion_filter
+      end
+
+      def configure_group(group)
+        @configuration.configure_group(group)
+      end
+
+      def example_count
+        example_groups.collect {|g| g.descendants}.flatten.inject(0) do |sum, g|
+          sum += g.filtered_examples.size
+        end
+      end
+
+      def preceding_declaration_line(filter_line)
+        declaration_line_numbers.sort.inject(nil) do |highest_prior_declaration_line, line|
+          line <= filter_line ? line : highest_prior_declaration_line
+        end
+      end
+
+      def reporter
+        @configuration.reporter
+      end
+
+      def announce_filters
+        filter_announcements = []
+
+        announce_inclusion_filter filter_announcements
+        announce_exclusion_filter filter_announcements
+
+        unless filter_manager.empty?
+          if filter_announcements.length == 1
+            reporter.message("Run options: #{filter_announcements[0]}")
+          else
+            reporter.message("Run options:\n  #{filter_announcements.join("\n  ")}")
+          end
+        end
+
+        if @configuration.run_all_when_everything_filtered? && example_count.zero?
+          reporter.message("#{everything_filtered_message}; ignoring #{inclusion_filter.description}")
+          filtered_examples.clear
+          inclusion_filter.clear
+        end
+
+        if example_count.zero?
+          example_groups.clear
+          if filter_manager.empty?
+            reporter.message("No examples found.")
+          elsif exclusion_filter.empty_without_conditional_filters?
+            message = everything_filtered_message
+            if @configuration.run_all_when_everything_filtered?
+              message << "; ignoring #{inclusion_filter.description}"
+            end
+            reporter.message(message)
+          elsif inclusion_filter.empty?
+            reporter.message(everything_filtered_message)
+          end
+        end
+      end
+
+      def everything_filtered_message
+        "\nAll examples were filtered out"
+      end
+
+      def announce_inclusion_filter(announcements)
+        unless inclusion_filter.empty?
+          announcements << "include #{inclusion_filter.description}"
+        end
+      end
+
+      def announce_exclusion_filter(announcements)
+        unless exclusion_filter.empty_without_conditional_filters?
+          announcements << "exclude #{exclusion_filter.description}"
+        end
+      end
+
+      def find_hook(hook, scope, group, example = nil)
+        @configuration.find_hook(hook, scope, group, example)
+      end
+
+    private
+
+      def declaration_line_numbers
+        @line_numbers ||= example_groups.inject([]) do |lines, g|
+          lines + g.declaration_line_numbers
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+if defined?(require_relative)
+  # @private
+  def require_rspec(path)
+    require_relative path
+  end
+else
+  # @private
+  def require_rspec(path)
+    require "rspec/#{path}"
+  end
+end
+
+require 'set'
+require_rspec 'core/filter_manager'
+require_rspec 'core/dsl'
+require_rspec 'core/extensions'
+require_rspec 'core/load_path'
+require_rspec 'core/deprecation'
+require_rspec 'core/backward_compatibility'
+require_rspec 'core/reporter'
+
+require_rspec 'core/metadata_hash_builder'
+require_rspec 'core/hooks'
+require_rspec 'core/subject'
+require_rspec 'core/let'
+require_rspec 'core/metadata'
+require_rspec 'core/pending'
+
+require_rspec 'core/world'
+require_rspec 'core/configuration'
+require_rspec 'core/project_initializer'
+require_rspec 'core/option_parser'
+require_rspec 'core/drb_options'
+require_rspec 'core/configuration_options'
+require_rspec 'core/command_line'
+require_rspec 'core/drb_command_line'
+require_rspec 'core/runner'
+require_rspec 'core/example'
+require_rspec 'core/shared_example_group'
+require_rspec 'core/example_group'
+require_rspec 'core/version'
+
+module RSpec
+  autoload :Matchers,      'rspec/matchers'
+  autoload :SharedContext, 'rspec/core/shared_context'
+
+  # @private
+  def self.wants_to_quit
+  # Used internally to determine what to do when a SIGINT is received
+    world.wants_to_quit
+  end
+
+  # @private
+  # Used internally to determine what to do when a SIGINT is received
+  def self.wants_to_quit=(maybe)
+    world.wants_to_quit=(maybe)
+  end
+
+  # @private
+  # Internal container for global non-configuration data
+  def self.world
+    @world ||= RSpec::Core::World.new
+  end
+
+  # @private
+  # Used internally to ensure examples get reloaded between multiple runs in
+  # the same process.
+  def self.reset
+    world.reset
+    configuration.reset
+  end
+
+  # Returns the global [Configuration](RSpec/Core/Configuration) object. While you
+  # _can_ use this method to access the configuration, the more common
+  # convention is to use [RSpec.configure](RSpec#configure-class_method).
+  #
+  # @example
+  #     RSpec.configuration.drb_port = 1234
+  # @see RSpec.configure
+  # @see Core::Configuration
+  def self.configuration
+    @configuration ||= RSpec::Core::Configuration.new
+  end
+
+  # Yields the global configuration to a block.
+  # @yield [Configuration] global configuration
+  #
+  # @example
+  #     RSpec.configure do |config|
+  #       config.add_formatter 'documentation'
+  #     end
+  # @see Core::Configuration
+  def self.configure
+    yield configuration if block_given?
+  end
+
+  # @private
+  # Used internally to clear remaining groups when fail_fast is set
+  def self.clear_remaining_example_groups
+    world.example_groups.clear
+  end
+
+  module Core
+  end
+end
+
+require_rspec 'core/backward_compatibility'

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

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe "autotest/discover.rb" do
+  context "with ./.rspec present" do
+    it "adds 'rspec2' to the list of discoveries" do
+      File.stub(:exist?).with("./.rspec") { true }
+      Autotest.should_receive(:add_discovery)
+      load File.expand_path("../../../lib/autotest/discover.rb", __FILE__)
+    end
+  end
+
+  context "with ./.rspec absent" do
+    it "does not add 'rspec2' to the list of discoveries" do
+      File.stub(:exist?) { false }
+      Autotest.should_not_receive(:add_discovery)
+      load File.expand_path("../../../lib/autotest/discover.rb", __FILE__)
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe "failed_results_re for autotest" do
+  def run_example
+    group = RSpec::Core::ExampleGroup.describe("group")
+    group.example("example") { yield }
+    io = StringIO.new
+    formatter = RSpec::Core::Formatters::BaseTextFormatter.new(io)
+    reporter = RSpec::Core::Reporter.new(formatter)
+
+    group.run(reporter)
+    reporter.report(1, nil) {}
+    io.string
+  end
+
+  shared_examples "autotest failed_results_re" do
+    it "matches a failure" do
+      output = run_example { fail }
+      output.should match(Autotest::Rspec2.new.failed_results_re)
+      output.should include(__FILE__.sub(File.expand_path('.'),'.'))
+    end
+
+    it "does not match when there are no failures" do
+      output = run_example { } # pass
+      output.should_not match(Autotest::Rspec2.new.failed_results_re)
+      output.should_not include(__FILE__.sub(File.expand_path('.'),'.'))
+    end
+  end
+
+  context "with color enabled" do
+    before do
+      RSpec.configuration.stub(:color_enabled? => true)
+    end
+
+    include_examples "autotest failed_results_re"
+  end
+
+  context "with color disabled " do
+    before do
+      RSpec.configuration.stub(:color_enabled? => false)
+    end
+
+    include_examples "autotest failed_results_re"
+  end
+end

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

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+describe Autotest::Rspec2 do
+  let(:rspec_autotest) { Autotest::Rspec2.new }
+  let(:spec_cmd) { File.expand_path("../../../exe/rspec", __FILE__) }
+  let(:ruby_cmd) { "ruby" }
+
+  before do
+    File.stub(:exist?) { false }
+  end
+
+  it "uses autotest's prefix" do
+    rspec_autotest.prefix = "this is the prefix "
+    rspec_autotest.
+      make_test_cmd({'a' => 'b'}).should match(/this is the prefix/)
+  end
+
+  describe "commands" do
+    before do
+      rspec_autotest.stub(:ruby => ruby_cmd)
+      files = %w[file_one file_two]
+      @files_to_test = {
+        files[0] => [],
+        files[1] => []
+      }
+      # this is not the inner representation of Autotest!
+      rspec_autotest.files_to_test = @files_to_test
+      @to_test = files.map { |f| File.expand_path(f) }.join ' '
+    end
+
+    it "makes the appropriate test command" do
+      actual_command = rspec_autotest.make_test_cmd(@files_to_test)
+      expected_command = /#{ruby_cmd}.*'#{spec_cmd}' (.*)/
+
+      actual_command.should match(expected_command)
+
+      actual_command =~ expected_command
+      $1.should =~ /#{File.expand_path('file_one')}/
+      $1.should =~ /#{File.expand_path('file_two')}/
+    end
+
+    it "returns a blank command for no files" do
+      rspec_autotest.make_test_cmd({}).should eq('')
+    end
+
+    it "quotes the paths of files to test" do
+      cmd = rspec_autotest.make_test_cmd(@files_to_test)
+      @files_to_test.keys.each do |file_to_test|
+        cmd.should match(/'#{File.expand_path(file_to_test)}'/)
+      end
+    end
+
+    it "gives '--tty' to #{Autotest::Rspec2::RSPEC_EXECUTABLE}, not '--autotest'" do
+      cmd = rspec_autotest.make_test_cmd(@files_to_test)
+      cmd.should match(' --tty ')
+      cmd.should_not match(' --autotest ')
+    end
+  end
+
+  describe "mappings" do
+    before do
+      @lib_file = "lib/something.rb"
+      @spec_file = "spec/something_spec.rb"
+      rspec_autotest.hook :initialize
+    end
+
+    it "finds the spec file for a given lib file" do
+      rspec_autotest.should map_specs([@spec_file]).to(@lib_file)
+    end
+
+    it "finds the spec file if given a spec file" do
+      rspec_autotest.should map_specs([@spec_file]).to(@spec_file)
+    end
+
+    it "ignores files in spec dir that aren't specs" do
+      rspec_autotest.should map_specs([]).to("spec/spec_helper.rb")
+    end
+
+    it "ignores untracked files (in @file)"  do
+      rspec_autotest.should map_specs([]).to("lib/untracked_file")
+    end
+  end
+
+  describe "consolidating failures" do
+    let(:subject_file) { "lib/autotest/some.rb" }
+    let(:spec_file)    { "spec/autotest/some_spec.rb" }
+
+    it "returns no failures if no failures were given in the output" do
+      rspec_autotest.consolidate_failures([[]]).should eq({})
+    end
+
+    it "returns a hash with the spec filename => spec name for each failure or error" do
+      failures = [ [ "false should be false", spec_file ] ]
+      rspec_autotest.consolidate_failures(failures).should eq({
+        spec_file => ["false should be false"]
+      })
+    end
+
+    context "when subject file appears before the spec file in the backtrace" do
+      let(:failures) do
+        [ [ "false should be false", "#{subject_file}:143:\n#{spec_file}:203:" ] ]
+      end
+
+      it "excludes the subject file" do
+        rspec_autotest.consolidate_failures(failures).keys.should_not include(subject_file)
+      end
+
+      it "includes the spec file" do
+        rspec_autotest.consolidate_failures(failures).keys.should include(spec_file)
+      end
+    end
+  end
+
+  describe "normalizing file names" do
+    it "ensures that a single file appears in files_to_test only once" do
+      @files_to_test = {}
+      ['filename.rb', './filename.rb', File.expand_path('filename.rb')].each do |file|
+        @files_to_test[file] = []
+      end
+      rspec_autotest.normalize(@files_to_test).should have(1).file
+    end
+  end
+end