rspec-core 2.0.0.beta.20 → 2.0.0.beta.22

data/lib/rspec/core/extensions/module_eval_with_args.rb

@@ -11,42 +11,22 @@ module RSpec
           # If there are no args and the block doesn't expect any, there's no
           # need to fake module_exec with our hack below.
           # Notes:
-          #   * lambda { }.arity # => -1
-          #   * lambda { || }.arity # => 0
-          #   * lambda { |*a| }.arity # -1
+          #   * lambda {      }.arity # => -1
+          #   * lambda { ||   }.arity # =>  0
+          #   * lambda { |*a| }.arity # => -1
           return module_eval(&block) if block.arity < 1 && args.size.zero?
 
+          orig_singleton_methods = singleton_methods
           instance_eval_with_args(*args, &block)
 
           # The only difference between instance_eval and module_eval is static method defs.
           #   * `def foo` in instance_eval defines a singleton method on the instance
           #   * `def foo` in class/module_eval defines an instance method for the class/module
-          # Here we deal with this difference by defining instance methods on the
-          # class/module and removing the singleton definitions.
-          singleton_class = class << self; self; end
-          extract_static_instance_method_defs_from(block).each do |m_name, m_def|
-            define_method(m_name, &m_def)
-            singleton_class.send(:remove_method, m_name)
-          end
-        end
-
-        private
-
-        def extract_static_instance_method_defs_from(block)
-          klass = Class.new do
-            # swallow any missing class method errors;
-            # we only care to capture the raw method definitions here.
-            def self.method_missing(*a); end
-
-            # skip any dynamic method definitions
-            def self.define_method(*a); end
-
-            # run the block so our instance methods get defined
-            class_eval(&block)
-          end
-
-          instance = klass.new
-          klass.instance_methods(false).inject({}) { |h, m| h[m] = instance.method(m); h }
+          # Here we deal with this difference by defining an instance method for
+          # each new singleton method.
+          # This has the side effect of duplicating methods (all new class methods will
+          # become instance methods and vice versa), but I don't see a way around it...
+          (singleton_methods - orig_singleton_methods).each { |m| define_method(m, &method(m)) }
         end
       end
     end

data/lib/rspec/core/extensions/object.rb

@@ -6,8 +6,6 @@ module RSpec
         args.last.update :caller => caller(1)
         RSpec::Core::ExampleGroup.describe(*args, &example_group_block)
       end
-
-      alias :context :describe
     end
   end
 end

data/lib/rspec/core/formatters/base_formatter.rb

@@ -38,6 +38,11 @@ module RSpec
           @example_group = example_group
         end
 
+        # This method is invoked at the end of the execution of each example group.
+        # +example_group+ is the example_group.
+        def example_group_finished(example_group)
+        end
+
         def add_example_group(example_group)
           RSpec.deprecate("add_example_group", "example_group_started")
           example_group_started(example_group)
@@ -93,10 +98,7 @@ module RSpec
         def format_backtrace(backtrace, example)
           return "" unless backtrace
           return backtrace if example.metadata[:full_backtrace] == true
-
-          cleansed = backtrace.select { |line| backtrace_line(line) }
-          # Kick the describe stack info off the list, just keep the line the problem happened on from that file
-          # cleansed = [cleansed.detect { |line| line.split(':').first == example.metadata[:caller].split(':').first }] if cleansed.size > 1
+          cleansed = backtrace.map { |line| backtrace_line(line) }.compact
           cleansed.empty? ? backtrace : cleansed
         end
 
@@ -108,8 +110,8 @@ module RSpec
 
         def backtrace_line(line)
           return nil if configuration.cleaned_from_backtrace?(line)
-          line.sub!(File.expand_path("."), ".")
-          line.sub!(/\A([^:]+:\d+)$/, '\\1')
+          line = line.sub(File.expand_path("."), ".")
+          line = line.sub(/\A([^:]+:\d+)$/, '\\1')
           return nil if line == '-e:1'
           line
         end

data/lib/rspec/core/formatters/base_text_formatter.rb

@@ -22,10 +22,18 @@ module RSpec
               output.puts "#{padding}Expected pending '#{example.metadata[:execution_result][:pending_message]}' to fail. No Error was raised."
             else
               output.puts "#{short_padding}#{index.next}) #{example.full_description}"
-              output.puts "#{padding}Failure/Error: #{read_failed_line(exception, example).strip}"
+              output.puts "#{padding}#{red("Failure/Error:")} #{red(read_failed_line(exception, example).strip)}"
               exception.message.split("\n").each do |line|
                 output.puts "#{padding}#{red(line)}"
               end
+
+              example.example_group.ancestors.push(example.example_group).each do |group|
+                if group.metadata[:shared_group_name]
+                  output.puts "#{padding}Shared Example Group: \"#{group.metadata[:shared_group_name]}\" called from " +
+                              "#{backtrace_line(group.metadata[:example_group][:location])}"
+                  break
+                end
+              end
             end
 
             format_backtrace(exception.backtrace, example).each do |backtrace_info|
@@ -48,18 +56,18 @@ module RSpec
 
         def dump_summary(duration, example_count, failure_count, pending_count)
           super(duration, example_count, failure_count, pending_count)
+          # Don't print out profiled info if there are failures, it just clutters the output
+          dump_profile if profile_examples? && failure_count == 0
           output.puts "\nFinished in #{format_seconds(duration)} seconds\n"
-
           output.puts colorise_summary(summary_line(example_count, failure_count, pending_count))
+        end
 
-          # Don't print out profiled info if there are failures, it just clutters the output
-          if profile_examples? && failure_count == 0
-            sorted_examples = examples.sort_by { |example| example.execution_result[:run_time] }.reverse.first(10)
-            output.puts "\nTop #{sorted_examples.size} slowest examples:\n"
-            sorted_examples.each do |example|
-              output.puts "  (#{format_seconds(example.execution_result[:run_time])} seconds) #{example}"
-              output.puts grey("   # #{format_caller(example.metadata[:location])}")
-            end
+        def dump_profile
+          sorted_examples = examples.sort_by { |example| example.execution_result[:run_time] }.reverse.first(10)
+          output.puts "\nTop #{sorted_examples.size} slowest examples:\n"
+          sorted_examples.each do |example|
+            output.puts "  #{example.full_description}"
+            output.puts grey("    #{red(format_seconds(example.execution_result[:run_time]))} #{red("seconds")} #{format_caller(example.metadata[:location])}")
           end
         end
 

data/lib/rspec/core/formatters/documentation_formatter.rb

@@ -6,20 +6,20 @@ module RSpec
 
         def initialize(output)
           super(output)
-          @previous_nested_example_groups = []
+          @group_level = 0
         end
 
         def example_group_started(example_group)
           super(example_group)
 
-          example_group_chain.each_with_index do |nested_example_group, i|
-            unless nested_example_group == @previous_nested_example_groups[i]
-              output.puts if i == 0
-              output.puts "#{'  ' * i}#{nested_example_group.description}"
-            end
-          end
+          output.puts if @group_level == 0
+          output.puts "#{'  ' * @group_level}#{example_group.description}"
 
-          @previous_nested_example_groups = example_group_chain
+          @group_level += 1
+        end
+
+        def example_group_finished(example_group)
+          @group_level -= 1
         end
 
         def example_passed(example)
@@ -55,7 +55,7 @@ module RSpec
         end
 
         def current_indentation
-          '  ' * @previous_nested_example_groups.size
+          '  ' * @group_level
         end
 
         def example_group_chain

data/lib/rspec/core/option_parser.rb

@@ -64,10 +64,6 @@ module RSpec::Core
           options[:line_number] = o
         end
 
-        parser.on('-o', '--options PATH', 'Read configuration options from a file path.  (Defaults to .rspec)') do |o|
-          options[:options_file] = o || local_options_file
-        end
-
         parser.on('-p', '--profile', 'Enable profiling of examples with output of the top 10 slowest examples') do |o|
           options[:profile_examples] = o
         end

data/lib/rspec/core/rake_task.rb

@@ -8,57 +8,94 @@ module RSpec
 
     class RakeTask < ::Rake::TaskLib
 
-      # Name of task. (default is :spec)
+      # Name of task.
+      #
+      # default:
+      #   :spec
       attr_accessor :name
 
-      # If true, requests that the specs be run with the warning flag set.
-      # E.g. warning=true implies "ruby -w" used to run the specs. Defaults to false.
-      attr_accessor :warning
-
-      # Glob pattern to match files. (default is 'spec/**/*_spec.rb')
+      # Glob pattern to match files.
+      #
+      # default:
+      #   'spec/**/*_spec.rb'
       attr_accessor :pattern
 
-      # Array of commandline options to pass to RSpec. Defaults to [].
-      attr_accessor :spec_opts
-
-      # The options to pass to ruby.  Defaults to blank
-      attr_accessor :ruby_opts
+      # Deprecated. Use ruby_opts="-w" instead.
+      # When true, requests that the specs be run with the warning flag set.
+      # e.g. "ruby -w"
+      #
+      # default:
+      #   false
+      attr_reader :warning
+
+      def warning=(true_or_false)
+        RSpec.deprecate("warning", 'ruby_opts="-w"')
+        @warning = true_or_false
+      end
 
       # Whether or not to fail Rake when an error occurs (typically when examples fail).
-      # Defaults to true.
+      #
+      # default:
+      #   true
       attr_accessor :fail_on_error
 
       # A message to print to stderr when there are failures.
       attr_accessor :failure_message
 
-      # Use verbose output. If this is set to true, the task will print
-      # the executed spec command to stdout. Defaults to false.
+      # Use verbose output. If this is set to true, the task will print the
+      # executed spec command to stdout.
+      #
+      # default:
+      #   false
       attr_accessor :verbose
 
-      # Use rcov for code coverage? defaults to false
+      # Use rcov for code coverage?
+      #
+      # default:
+      #   false
       attr_accessor :rcov
 
-      # Path to rcov.  You can set this to 'bundle exec rcov' if you bundle rcov.
+      # Path to rcov.
+      #
+      # defaults:
+      #   'rcov'
       attr_accessor :rcov_path
 
-      # The options to pass to rcov.  Defaults to blank
+      # Command line options to pass to rcov.
+      #
+      # default:
+      #   nil
       attr_accessor :rcov_opts
 
+      # Command line options to pass to ruby.
+      #
+      # default:
+      #   nil
+      attr_accessor :ruby_opts
+
+      # Command line options to pass to rspec.
+      #
+      # default:
+      #   nil
+      attr_accessor :rspec_opts
+
+      # Deprecated. Use rspec_opts instead.
+      def spec_opts=(opts)
+        RSpec.deprecate("spec_opts","rspec_opts")
+        @rspec_opts = opts
+      end
+
       def initialize(*args)
         @name = args.shift || :spec
-        @pattern, @rcov_path, @rcov_opts, @ruby_opts = nil, nil, nil, nil
+        @pattern, @rcov_path, @rcov_opts, @ruby_opts, @rspec_opts = nil, nil, nil, nil, nil
         @warning, @rcov = false, false
         @fail_on_error = true
-        @spec_opts = []
 
         yield self if block_given?
+
         @rcov_path ||= 'rcov'
         @pattern ||= './spec/**/*_spec.rb'
-        define
-      end
 
-      def define # :nodoc:
-        actual_name = Hash === name ? name.keys.first : name
         desc("Run RSpec code examples") unless ::Rake.application.last_comment
 
         task name do
@@ -67,47 +104,56 @@ module RSpec
               puts "No examples matching #{pattern} could be found"
             else
               puts spec_command.inspect if verbose
-              unless ruby("-S #{spec_command}")
+              unless ruby(spec_command)
                 STDERR.puts failure_message if failure_message
                 raise("#{spec_command} failed") if fail_on_error
               end
             end
           end
         end
-
-        self
       end
 
       def files_to_run # :nodoc:
-        FileList[ pattern ].to_a
+        FileList[ pattern ].map { |f| %["#{f}"] }
       end
 
     private
 
       def spec_command
         @spec_command ||= begin
-                            cmd_parts = %w[-Ilib -Ispec]
-                            cmd_parts << "-w" if warning
-                            cmd_parts.unshift runner_options
-                            cmd_parts.unshift runner
-                            cmd_parts.unshift bundler
-                            cmd_parts += files_to_run.map { |fn| %["#{fn}"] }
-                            cmd_parts << spec_opts.join(" ")
-                            cmd_parts.join(" ")
+                            cmd_parts = [ruby_opts]
+                            cmd_parts << "-w" if warning?
+                            cmd_parts << "-S"
+                            cmd_parts << "bundle exec" if bundler?
+                            cmd_parts << runner
+                            cmd_parts << runner_options 
+                            cmd_parts << files_to_run
+                            cmd_parts.flatten.compact.reject(&blank).join(" ")
                           end
       end
 
+    private
+
       def runner
-        rcov ? rcov_path : RUBY
+        rcov ? rcov_path : 'rspec'
       end
 
       def runner_options
-        rcov ? [rcov_opts] : [ruby_opts]
+        rcov ? [rcov_opts] : [rspec_opts]
       end
 
-      def bundler
-        File.exist?("./Gemfile") ? "bundle exec " : ""
+      def bundler?
+        File.exist?("./Gemfile")
       end
+
+      def warning?
+        warning
+      end
+
+      def blank
+        lambda {|s| s == ""}
+      end
+
     end
 
   end

data/lib/rspec/core/reporter.rb

@@ -2,13 +2,20 @@ module RSpec::Core
   class Reporter
     def initialize(*formatters)
       @formatters = formatters
-      @failure_count = @pending_count = 0
+      @example_count = @failure_count = @pending_count = 0
     end
 
     def report(count)
       start(count)
       begin
         yield self
+      ensure
+        conclude
+      end
+    end
+
+    def conclude
+      begin
         stop
         notify :start_dump
         notify :dump_pending
@@ -19,10 +26,11 @@ module RSpec::Core
       end
     end
 
-    def start(example_count)
-      @example_count = example_count
+    alias_method :abort, :conclude
+
+    def start(expected_example_count)
       @start = Time.now
-      notify :start, example_count
+      notify :start, expected_example_count
     end
 
     def message(message)
@@ -33,7 +41,12 @@ module RSpec::Core
       notify :example_group_started, group
     end
 
+    def example_group_finished(group)
+      notify :example_group_finished, group
+    end
+
     def example_started(example)
+      @example_count += 1
       notify :example_started, example
     end
 
@@ -52,7 +65,7 @@ module RSpec::Core
     end
 
     def stop
-      @duration = Time.now - @start
+      @duration = Time.now - @start if @start
       notify :stop
     end
 

data/lib/rspec/core/runner.rb

@@ -4,30 +4,20 @@ module RSpec
   module Core
     class Runner
 
-      def self.autorun
-        return if autorun_disabled? || installed_at_exit? || running_in_drb?
-        @installed_at_exit = true
-        at_exit { run(ARGV, $stderr, $stdout) ? exit(0) : exit(1) }
-      end
-
-      def self.autorun_disabled?
-        @autorun_disabled ||= false
-      end
-
       def self.disable_autorun!
-        @autorun_disabled = true
+        RSpec.deprecate("disable_autorun!")
       end
 
-      def self.installed_at_exit?
-        @installed_at_exit ||= false
-      end
-
-      def self.running_in_drb?
-        (DRb.current_server rescue false) &&
-        !!((DRb.current_server.uri) =~ /druby\:\/\/127.0.0.1\:/)
+      def self.trap_interrupt
+        trap('INT') do
+          exit!(1) if RSpec.wants_to_quit
+          RSpec.wants_to_quit = true
+          STDERR.puts "\nExiting... Interrupt again to exit immediately."
+        end
       end
 
       def self.run(args, err, out)
+        trap_interrupt
         options = ConfigurationOptions.new(args)
         options.parse_options