rspec-core 2.0.0.beta.22 → 2.6.4

data/lib/rspec/core/reporter.rb

@@ -3,6 +3,7 @@ module RSpec::Core
     def initialize(*formatters)
       @formatters = formatters
       @example_count = @failure_count = @pending_count = 0
+      @duration = @start = nil
     end
 
     def report(count)
@@ -10,11 +11,11 @@ module RSpec::Core
       begin
         yield self
       ensure
-        conclude
+        finish
       end
     end
 
-    def conclude
+    def finish
       begin
         stop
         notify :start_dump
@@ -26,7 +27,7 @@ module RSpec::Core
       end
     end
 
-    alias_method :abort, :conclude
+    alias_method :abort, :finish
 
     def start(expected_example_count)
       @start = Time.now
@@ -38,11 +39,11 @@ module RSpec::Core
     end
 
     def example_group_started(group)
-      notify :example_group_started, group
+      notify :example_group_started, group unless group.descendant_filtered_examples.empty?
     end
 
     def example_group_finished(group)
-      notify :example_group_finished, group
+      notify :example_group_finished, group unless group.descendant_filtered_examples.empty?
     end
 
     def example_started(example)

data/lib/rspec/core/ruby_project.rb

@@ -27,9 +27,9 @@ module RSpec
         ascend_until {|path| File.exists?(File.join(path, dir))}
       end
 
-      def ascend_until(&block) # :nodoc:
+      def ascend_until # :nodoc:
         Pathname(File.expand_path('.')).ascend do |path|
-          return path if block.call(path)
+          return path if yield(path)
         end
       end
 

data/lib/rspec/core/runner.rb

@@ -4,11 +4,32 @@ module RSpec
   module Core
     class Runner
 
+      # Register an at_exit hook that runs the suite.
+      def self.autorun
+        return if autorun_disabled? || installed_at_exit? || running_in_drb?
+        @installed_at_exit = true
+        at_exit { exit(run(ARGV, $stderr, $stdout).to_i) }
+      end
+      AT_EXIT_HOOK_BACKTRACE_LINE = "#{__FILE__}:#{__LINE__ - 2}:in `autorun'"
+
       def self.disable_autorun!
-        RSpec.deprecate("disable_autorun!")
+        @autorun_disabled = true
+      end
+
+      def self.autorun_disabled? # :nodoc:
+        @autorun_disabled ||= false
+      end
+
+      def self.installed_at_exit? # :nodoc:
+        @installed_at_exit ||= false
+      end
+
+      def self.running_in_drb? # :nodoc:
+        (DRb.current_server rescue false) &&
+         DRb.current_server.uri =~ /druby\:\/\/127.0.0.1\:/
       end
 
-      def self.trap_interrupt
+      def self.trap_interrupt # :nodoc:
         trap('INT') do
           exit!(1) if RSpec.wants_to_quit
           RSpec.wants_to_quit = true
@@ -16,23 +37,46 @@ module RSpec
         end
       end
 
-      def self.run(args, err, out)
+      # Run a suite of RSpec examples.
+      #
+      # This is used internally by RSpec to run a suite, but is available
+      # for use by any other automation tool.
+      #
+      # If you want to run this multiple times in the same process, and you
+      # want files like spec_helper.rb to be reloaded, be sure to load `load`
+      # instead of `require`.
+      #
+      # ==== Parameters
+      # * +args+ - an array of command-line-supported arguments
+      # * +err+ - error stream (Default: $stderr)
+      # * +out+ - output stream (Default: $stdout)
+      #
+      # ==== Returns
+      # * +Fixnum+ - exit status code (0/1)
+      def self.run(args, err=$stderr, out=$stdout)
         trap_interrupt
         options = ConfigurationOptions.new(args)
         options.parse_options
 
         if options.options[:drb]
-          run_over_drb(options, err, out) || run_in_process(options, err, out)
+          begin
+            run_over_drb(options, err, out)
+          rescue DRb::DRbConnError
+            err.puts "No DRb server is running. Running in local process instead ..."
+            run_in_process(options, err, out)
+          end
         else
           run_in_process(options, err, out)
         end
+      ensure
+        RSpec.reset
       end
 
-      def self.run_over_drb(options, err, out)
+      def self.run_over_drb(options, err, out) # :nodoc:
         DRbCommandLine.new(options).run(err, out)
       end
 
-      def self.run_in_process(options, err, out)
+      def self.run_in_process(options, err, out) # :nodoc:
         CommandLine.new(options, RSpec::configuration, RSpec::world).run(err, out)
       end
 

data/lib/rspec/core/shared_context.rb

@@ -0,0 +1,16 @@
+module RSpec
+  module Core
+    module SharedContext
+      include Hooks
+
+      def included(group)
+        [:before, :after].each do |type|
+          [:all, :each].each do |scope|
+            group.hooks[type][scope].concat hooks[type][scope]
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rspec/core/shared_example_group.rb

@@ -2,11 +2,27 @@ module RSpec
   module Core
     module SharedExampleGroup
 
-      def share_examples_for(name, &block)
-        ensure_shared_example_group_name_not_taken(name)
-        RSpec.world.shared_example_groups[name] = block
+      def shared_context(*args, &block)
+        if String === args.first || Symbol === args.first
+          name = args.shift
+          ensure_shared_example_group_name_not_taken(name)
+          RSpec.world.shared_example_groups[name] = block
+        end
+
+        unless args.empty?
+          mod = Module.new
+          (class << mod; self; end).send(:define_method, :extended) do |host|
+            host.class_eval(&block)
+          end
+          RSpec.configuration.extend(mod, *args)
+        else
+        end
       end
 
+      alias :shared_examples     :shared_context
+      alias :share_examples_for  :shared_context
+      alias :shared_examples_for :shared_context
+
       def share_as(name, &block)
         if Object.const_defined?(name)
           mod = Object.const_get(name)
@@ -31,7 +47,6 @@ module RSpec
         RSpec.world.shared_example_groups[shared_const] = block
       end
 
-      alias :shared_examples_for :share_examples_for
 
     private
 

data/lib/rspec/core/subject.rb

@@ -1,67 +1,72 @@
 module RSpec
   module Core
     module Subject
+      module InstanceMethods
 
-      def self.included(kls)
-        kls.class_eval do
-          extend ClassMethods
-          alias_method :__should_for_example_group__,     :should
-          alias_method :__should_not_for_example_group__, :should_not
+        # 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.
+        #
+        # == Examples
+        #
+        #   # 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
-      end
 
-      # 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.
-      #
-      # == Examples
-      #
-      #   # 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
-        @original_subject ||= instance_eval(&self.class.subject)
-      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.
-      #
-      # == Examples
-      #
-      #   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
+          # 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.
+          #
+          # == Examples
+          #
+          #   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.
-      #
-      # == Examples
-      #
-      #   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)
+          # Just like +should+, +should_not+ delegates to the subject (implicit or
+          # explicit) of the example group.
+          #
+          # == Examples
+          #
+          #   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 ClassMethods
@@ -85,23 +90,45 @@ module RSpec
         # 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 
-        #     let(:person) do
-        #       person = Person.new
-        #       person.phone_numbers << "555-1212"
+        #
+        #   describe Person do
+        #     subject do
+        #       Person.new.tap do |person|
+        #         person.phone_numbers << "555-1212"
+        #       end
         #     end
         #
         #     its("phone_numbers.first") { should == "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 == 3 }
+        #     its(['admin']) { should == :all_permissions }
+        #
+        #     # You can still access to its regular methods this way:
+        #     its(:keys) { should include(:max_users) }
+        #     its(:count) { should == 2 }
+        #   end
         def its(attribute, &block)
           describe(attribute) do
             example do
               self.class.class_eval do
                 define_method(:subject) do
-                  attribute.to_s.split('.').inject(super()) do |target, method|
-                    target.send(method)
-                  end
+                  @_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)
@@ -127,7 +154,7 @@ module RSpec
 
         attr_reader :explicit_subject_block # :nodoc:
 
-      private
+        private
 
         def explicit_subject
           group = self

data/lib/rspec/core/version.rb

@@ -1,7 +1,7 @@
 module RSpec # :nodoc:
   module Core # :nodoc:
     module Version # :nodoc:
-      STRING = '2.0.0.beta.22'
+      STRING = '2.6.4'
     end
   end
 end

data/lib/rspec/core/world.rb

@@ -2,7 +2,31 @@ module RSpec
   module Core
     class World
 
-      attr_reader :example_groups, :filtered_examples
+      module Describable
+        PROC_HEX_NUMBER = /0x[0-9a-f]+@/
+        PROJECT_DIR = File.expand_path('.')
+
+        def description
+          reject { |k, v| RSpec::Core::Configuration::CONDITIONAL_FILTERS[k] == v }.inspect.gsub(PROC_HEX_NUMBER, '').gsub(PROJECT_DIR, '.').gsub(' (lambda)','')
+        end
+
+        def empty_without_conditional_filters?
+          reject { |k, v| RSpec::Core::Configuration::CONDITIONAL_FILTERS[k] == v }.empty?
+        end
+
+        def reject
+          super rescue {}
+        end
+
+        def empty?
+          super rescue false
+        end
+      end
+
+      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
@@ -10,19 +34,28 @@ module RSpec
         @filtered_examples = Hash.new { |hash,group|
           hash[group] = begin
             examples = group.examples.dup
-            examples = apply_exclusion_filters(examples, exclusion_filter) if exclusion_filter
-            examples = apply_inclusion_filters(examples, inclusion_filter) if inclusion_filter
+            examples = apply_exclusion_filters(examples, exclusion_filter)
+            examples = apply_inclusion_filters(examples, inclusion_filter)
             examples.uniq
           end
         }
       end
 
+      def reset
+        example_groups.clear
+      end
+
+      def register(example_group)
+        example_groups << example_group
+        example_group
+      end
+
       def inclusion_filter
-        @configuration.filter
+        @configuration.inclusion_filter.extend(Describable)
       end
 
       def exclusion_filter
-        @configuration.exclusion_filter
+        @configuration.exclusion_filter.extend(Describable)
       end
 
       def configure_group(group)
@@ -38,51 +71,76 @@ module RSpec
       end
 
       def apply_inclusion_filters(examples, conditions={})
-        examples.select(&all_apply?(conditions))
+        examples.select(&apply?(:any?, conditions))
       end
 
       alias_method :find, :apply_inclusion_filters
 
       def apply_exclusion_filters(examples, conditions={})
-        examples.reject(&all_apply?(conditions))
+        examples.reject(&apply?(:any?, conditions))
       end
 
       def preceding_declaration_line(filter_line)
-        declaration_line_numbers.inject(nil) do |highest_prior_declaration_line, line|
+        declaration_line_numbers.sort.inject(nil) do |highest_prior_declaration_line, line|
           line <= filter_line ? line : highest_prior_declaration_line
         end
       end
 
-      def announce_inclusion_filter
-        if inclusion_filter
-          if @configuration.run_all_when_everything_filtered? && RSpec.world.example_count.zero?
-            @configuration.reporter.message "No examples were matched by #{inclusion_filter.inspect}, running all"
-            @configuration.clear_inclusion_filter
-            filtered_examples.clear
-          else
-            @configuration.reporter.message "Run filtered using #{inclusion_filter.inspect}"
+      def reporter
+        @configuration.reporter
+      end
+
+      def announce_filters
+        filter_announcements = []
+
+        if @configuration.run_all_when_everything_filtered? && example_count.zero?
+          reporter.message( "No examples matched #{inclusion_filter.description}. Running all.")
+          filtered_examples.clear
+          @configuration.clear_inclusion_filter
+        end
+
+        announce_inclusion_filter filter_announcements
+        announce_exclusion_filter filter_announcements
+
+        if example_count.zero?
+          example_groups.clear
+          if filter_announcements.empty?
+            reporter.message("No examples found.")
+          elsif !inclusion_filter.empty?
+            message = "No examples matched #{inclusion_filter.description}."
+            if @configuration.run_all_when_everything_filtered?
+              message << " Running all."
+            end
+            reporter.message(message)
+          elsif !exclusion_filter.empty?
+            reporter.message(
+              "No examples were matched. Perhaps #{exclusion_filter.description} is excluding everything?")
           end
+        elsif !filter_announcements.empty?
+          reporter.message("Run filtered #{filter_announcements.join(', ')}")
         end
       end
-      
-      def announce_exclusion_filter
-        if exclusion_filter && RSpec.world.example_count.zero?
-          @configuration.reporter.message(
-            "No examples were matched. Perhaps #{exclusion_filter.inspect} is excluding everything?")
-          example_groups.clear
+
+      def announce_inclusion_filter(announcements)
+        unless inclusion_filter.empty?
+          announcements << "including #{inclusion_filter.description}"
         end
       end
 
-      include RSpec::Core::Hooks
+      def announce_exclusion_filter(announcements)
+        unless exclusion_filter.empty_without_conditional_filters?
+          announcements << "excluding #{exclusion_filter.description}"
+        end
+      end
 
-      def find_hook(hook, scope, group)
-        @configuration.find_hook(hook, scope, group)
+      def find_hook(hook, scope, group, example = nil)
+        @configuration.find_hook(hook, scope, group, example)
       end
 
     private
 
-      def all_apply?(conditions)
-        lambda {|example| example.metadata.all_apply?(conditions)}
+      def apply?(predicate, filter)
+        lambda {|example| filter.empty? || example.metadata.apply?(predicate, filter)}
       end
 
       def declaration_line_numbers