horseman 0.0.4 → 0.0.5

data/vendor/ruby/1.9.1/gems/rspec-core-2.8.0/lib/rspec/core/subject.rb

@@ -1,175 +0,0 @@
-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
-      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
-                  @_subject ||= if attribute.is_a?(Array)
-                                  super()[*attribute]
-                                else
-                                  attribute.to_s.split('.').inject(super()) do |target, method|
-                                    target.send(method)
-                                  end
-                                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/ruby/1.9.1/gems/rspec-core-2.8.0/lib/rspec/core/version.rb

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

data/vendor/ruby/1.9.1/gems/rspec-core-2.8.0/lib/rspec/core/world.rb

@@ -1,132 +0,0 @@
-module RSpec
-  module Core
-    class World
-
-      include RSpec::Core::Hooks
-
-      attr_reader :example_groups, :filtered_examples, :wants_to_quit
-      attr_writer :wants_to_quit
-
-      def initialize(configuration=RSpec.configuration)
-        @configuration = configuration
-        @example_groups = [].extend(Extensions::Ordered)
-        @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
-      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 shared_example_groups
-        @shared_example_groups ||= {}
-      end
-
-      def example_count
-        example_groups.collect {|g| g.descendants}.flatten.inject(0) { |sum, g| sum += g.filtered_examples.size }
-      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/ruby/1.9.1/gems/rspec-core-2.8.0/lib/rspec/monkey.rb

@@ -1 +0,0 @@
-require_rspec 'monkey/spork/test_framework/rspec.rb'

data/vendor/ruby/1.9.1/gems/rspec-core-2.8.0/lib/rspec/monkey/spork/test_framework/rspec.rb

@@ -1,10 +0,0 @@
-# TODO (2011-05-08) - remove this as soon as spork 0.9.0 is released
-if defined?(Spork::TestFramework::RSpec)
-  # @private
-  class Spork::TestFramework::RSpec < Spork::TestFramework
-    # @private
-    def run_tests(argv, err, out)
-      ::RSpec::Core::CommandLine.new(argv).run(err, out)
-    end
-  end
-end

data/vendor/ruby/1.9.1/gems/rspec-core-2.8.0/spec/autotest/discover_spec.rb

@@ -1,19 +0,0 @@
-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/ruby/1.9.1/gems/rspec-core-2.8.0/spec/autotest/rspec_spec.rb

@@ -1,123 +0,0 @@
-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