typo 5.1.3 → 5.1.98

data/vendor/plugins/rspec/lib/spec/runner/formatter/progress_bar_formatter.rb

@@ -14,9 +14,9 @@ module Spec
           @output.flush
         end
       
-        def example_pending(example_group_description, example, message)
+        def example_pending(example, message, pending_caller)
           super
-          @output.print yellow('P')
+          @output.print yellow('*')
           @output.flush
         end
         
@@ -24,6 +24,10 @@ module Spec
           @output.puts
           @output.flush
         end
+        
+        def method_missing(sym, *args)
+          # ignore
+        end
       end
     end
   end

data/vendor/plugins/rspec/lib/spec/runner/formatter/specdoc_formatter.rb

@@ -28,7 +28,7 @@ module Spec
           output.flush
         end
         
-        def example_pending(example_group_description, example, message)
+        def example_pending(example, message, pending_caller)
           super
           output.puts yellow("- #{example.description} (PENDING: #{message})")
           output.flush

data/vendor/plugins/rspec/lib/spec/runner/formatter/story/html_formatter.rb

@@ -8,6 +8,15 @@ module Spec
         class HtmlFormatter < BaseTextFormatter
           include ERB::Util
           
+          def initialize(options, where)
+            super
+            @previous_type = nil
+            @scenario_text = ""
+            @story_text = ""
+            @scenario_failed = false
+            @story_failed = false
+          end
+          
           def run_started(count)
             @output.puts <<-EOF
 <?xml version="1.0" encoding="UTF-8"?>
@@ -49,8 +58,8 @@ EOF
           end
           
           def story_started(title, narrative)
-            @output.puts <<-EOF
-      <dl class="story passed">
+            @story_failed = false
+            @story_text = <<-EOF 
         <dt>Story: #{h title}</dt>
         <dd>
           <p>
@@ -59,27 +68,49 @@ EOF
 EOF
           end
 
-          def story_ended(title, narrative)
-            @output.puts <<-EOF
+          def story_ended(title, narrative)     
+            if @story_failed
+              @output.puts <<-EOF
+      <dl class="story failed">
+EOF
+            else
+              @output.puts <<-EOF
+      <dl class="story passed">
+EOF
+            end
+              @output.puts <<-EOF
+#{@story_text}
         </dd>
       </dl>
 EOF
           end
-
+     
           def scenario_started(story_title, scenario_name)
-            @output.puts <<-EOF
-          <dl class="passed">
-            <dt>Scenario: #{h scenario_name}</dt>
-            <dd>
-              <ul class="steps">
+            @previous_type = nil
+            @scenario_failed = false
+            @scenario_text = <<-EOF
+              <dt>Scenario: #{h scenario_name}</dt>
+              <dd>
+                <ul class="steps">
 EOF
           end
 
           def scenario_ended
-            @output.puts <<-EOF
-              </ul>
-            </dd>
-          </dl>
+            if @scenario_failed
+              @story_text += <<-EOF
+            <dl class="failed">
+EOF
+            else
+              @story_text += <<-EOF
+            <dl class="passed">
+EOF
+            end
+            
+            @story_text += <<-EOF
+#{@scenario_text}
+                </ul>
+              </dd>
+            </dl>
 EOF
           end
           
@@ -95,6 +126,8 @@ EOF
           end
 
           def scenario_failed(story_title, scenario_name, err)
+            @scenario_failed = true
+            @story_failed = true
             scenario_ended
           end
 
@@ -117,9 +150,22 @@ EOF
             spans = args.map { |arg| "<span class=\"param\">#{arg}</span>" }
             desc_string = description.step_name
             arg_regexp = description.arg_regexp           
+            inner = if(type == @previous_type)
+              "And "
+            else
+              "#{type.to_s.capitalize} "
+            end
             i = -1
-            inner = type.to_s.capitalize + ' ' + desc_string.gsub(arg_regexp) { |param| spans[i+=1] }
-            @output.puts "                <li class=\"#{klass}\">#{inner}</li>"
+            inner += desc_string.gsub(arg_regexp) { |param| spans[i+=1] }
+            
+            @scenario_text += "                  <li class=\"#{klass}\">#{inner}</li>\n"
+            
+            if type == :'given scenario'
+              @previous_type = :given
+            else
+              @previous_type = type
+            end
+            
           end
         end
       end

data/vendor/plugins/rspec/lib/spec/runner/formatter/story/plain_text_formatter.rb

@@ -9,9 +9,22 @@ module Spec
             super
             @successful_scenario_count = 0
             @pending_scenario_count = 0
+            
+            @pre_story_pending_count = 0
+            @pre_story_successful_count = 0
+            
             @failed_scenarios = []
             @pending_steps = []
-            @previous_type = nil
+            @previous_type = nil 
+            
+            @scenario_body_text = ""
+            @story_body_text = ""
+            
+            @scenario_head_text = ""
+            @story_head_text = ""
+                  
+            @scenario_failed = false
+            @story_failed = false
           end
         
           def run_started(count)
@@ -20,15 +33,30 @@ module Spec
           end
 
           def story_started(title, narrative)
+            @pre_story_pending_count = @pending_scenario_count
+            @pre_story_successful_count = @successful_scenario_count
+            
             @current_story_title = title
-            @output.puts "Story: #{title}\n\n"
+            @story_failed = false
+            @story_body_text = ""
+            @story_head_text = "Story: #{title}\n\n"
+
             narrative.each_line do |line|
-              @output.print "  "
-              @output.print line
+              @story_head_text += "  "
+              @story_head_text += line
             end
           end
         
           def story_ended(title, narrative)
+            if @story_failed
+              @output.print red(@story_head_text)
+            elsif @pre_story_successful_count == @successful_scenario_count && 
+                  @pending_scenario_count >= @pre_story_pending_count
+              @output.print yellow(@story_head_text)
+            else              
+              @output.print green(@story_head_text)
+            end
+            @output.print @story_body_text
             @output.puts
             @output.puts
           end
@@ -36,27 +64,54 @@ module Spec
           def scenario_started(story_title, scenario_name)
             @current_scenario_name = scenario_name
             @scenario_already_failed = false
-            @output.print "\n\n  Scenario: #{scenario_name}"
+            @scenario_head_text = "\n\n  Scenario: #{scenario_name}"
+            @scenario_body_text = ""
             @scenario_ok = true
+            @scenario_pending = false
+            @scenario_failed = false
           end
         
           def scenario_succeeded(story_title, scenario_name)
             @successful_scenario_count += 1
+            scenario_ended
           end
         
           def scenario_failed(story_title, scenario_name, err)
             @options.backtrace_tweaker.tweak_backtrace(err)
             @failed_scenarios << [story_title, scenario_name, err] unless @scenario_already_failed
             @scenario_already_failed = true
+            @story_failed = true
+            @scenario_failed = true
+            scenario_ended
           end
         
           def scenario_pending(story_title, scenario_name, msg)
             @pending_scenario_count += 1 unless @scenario_already_failed
+            @scenario_pending = true
             @scenario_already_failed = true
+            scenario_ended
           end
         
+          def scenario_ended
+            if @scenario_failed
+              @story_body_text += red(@scenario_head_text)
+            elsif @scenario_pending
+              @story_body_text += yellow(@scenario_head_text)
+            else
+              @story_body_text += green(@scenario_head_text)
+            end
+            @story_body_text += @scenario_body_text
+          end
+          
           def run_ended
-            @output.puts "#@count scenarios: #@successful_scenario_count succeeded, #{@failed_scenarios.size} failed, #@pending_scenario_count pending"
+            summary_text = "#@count scenarios: #@successful_scenario_count succeeded, #{@failed_scenarios.size} failed, #@pending_scenario_count pending"
+            if !@failed_scenarios.empty?
+              @output.puts red(summary_text)
+            elsif !@pending_steps.empty?
+              @output.puts yellow(summary_text)
+            else
+              @output.puts green(summary_text)
+            end
             unless @pending_steps.empty?
               @output.puts "\nPending Steps:"
               @pending_steps.each_with_index do |pending, i|
@@ -68,11 +123,10 @@ module Spec
               @output.print "\nFAILURES:"
               @failed_scenarios.each_with_index do |failure, i|
                 title, scenario_name, err = failure
-                @output.print %[
-    #{i+1}) #{title} (#{scenario_name}) FAILED
-    #{err.class}: #{err.message}
-    #{err.backtrace.join("\n")}
-]
+                @output.print "\n    #{i+1}) "
+                @output.print red("#{title} (#{scenario_name}) FAILED")
+                @output.print red("\n    #{err.class}: #{err.message}")
+                @output.print "\n    #{err.backtrace.join("\n")}\n"
               end
             end            
           end
@@ -81,19 +135,24 @@ module Spec
           end
                   
           def step_succeeded(type, description, *args)
-            found_step(type, description, false, *args)
+            found_step(type, description, false, false, *args)
           end
         
           def step_pending(type, description, *args)
-            found_step(type, description, false, *args)
+            found_step(type, description, false, true, *args)
             @pending_steps << [@current_story_title, @current_scenario_name, description]
-            @output.print " (PENDING)"
+            @scenario_body_text +=  yellow(" (PENDING)")
+            @scenario_pending = true
             @scenario_ok = false
           end
         
           def step_failed(type, description, *args)
-            found_step(type, description, true, *args)
-            @output.print red(@scenario_ok ? " (FAILED)" : " (SKIPPED)")
+            found_step(type, description, true, @scenario_pending, *args)
+            if @scenario_pending
+              @scenario_body_text +=  yellow(" (SKIPPED)")
+            else
+              @scenario_body_text +=  red(@scenario_ok ? " (FAILED)" : " (SKIPPED)")
+            end
             @scenario_ok = false
           end
           
@@ -106,7 +165,7 @@ module Spec
 
         private
 
-          def found_step(type, description, failed, *args)
+          def found_step(type, description, failed, pending, *args)
             desc_string = description.step_name
             arg_regexp = description.arg_regexp
             text = if(type == @previous_type)
@@ -116,7 +175,11 @@ module Spec
             end
             i = -1
             text << desc_string.gsub(arg_regexp) { |param| args[i+=1] }
-            @output.print(failed ? red(text) : green(text))
+            if pending
+              @scenario_body_text += yellow(text)
+            else
+              @scenario_body_text += (failed ? red(text) : green(text))
+            end
 
             if type == :'given scenario'
               @previous_type = :given

data/vendor/plugins/rspec/lib/spec/runner/formatter/story/progress_bar_formatter.rb

@@ -0,0 +1,42 @@
+require 'spec/runner/formatter/story/plain_text_formatter'
+
+module Spec
+  module Runner
+    module Formatter
+      module Story
+        class ProgressBarFormatter < PlainTextFormatter
+
+          def story_started(title, narrative) end
+          def story_ended(title, narrative) end
+
+          def run_started(count)
+            @start_time = Time.now
+            super
+          end
+          
+          def run_ended
+            @output.puts
+            @output.puts
+            @output.puts "Finished in %f seconds" % (Time.now - @start_time)
+            @output.puts
+            super
+          end
+
+          def scenario_ended
+            if @scenario_failed
+              @output.print red('F')
+              @output.flush
+            elsif @scenario_pending
+              @output.print yellow('P')
+              @output.flush
+            else
+              @output.print green('.')
+              @output.flush
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/vendor/plugins/rspec/lib/spec/runner/heckle_runner.rb

@@ -25,7 +25,7 @@ module Spec
       
       def heckle_method(class_name, method_name)
         verify_constant(class_name)
-        heckle = @heckle_class.new(class_name, method_name, rspec_options)
+        heckle = @heckle_class.new(class_name, method_name, Spec::Runner.options)
         heckle.validate
       end
       
@@ -39,7 +39,7 @@ module Spec
         
         classes.each do |klass|
           klass.instance_methods(false).each do |method_name|
-            heckle = @heckle_class.new(klass.name, method_name, rspec_options)
+            heckle = @heckle_class.new(klass.name, method_name, Spec::Runner.options)
             heckle.validate
           end
         end

data/vendor/plugins/rspec/lib/spec/runner/option_parser.rb

@@ -19,7 +19,7 @@ module Spec
                                                  "Separate multiple patterns with commas.",
                                                  "Applies only to directories named on the command line (files",
                                                  "named explicitly on the command line will be loaded regardless)."],
-        :diff =>    ["-D", "--diff [FORMAT]", "Show diff of objects that are expected to be equal when they are not",
+        :diff =>    ["-D", "--diff [FORMAT]","Show diff of objects that are expected to be equal when they are not",
                                              "Builtin formats: unified|u|context|c",
                                              "You can also specify a custom differ class",
                                              "(in which case you should also specify --require)"],
@@ -34,36 +34,38 @@ module Spec
                                                           "an example name directly, causing RSpec to run just the example",
                                                           "matching that name"],
         :specification => ["-s", "--specification [NAME]", "DEPRECATED - use -e instead", "(This will be removed when autotest works with -e)"],
-        :line => ["-l", "--line LINE_NUMBER", Integer, "Execute behaviout or specification at given line.",
+        :line => ["-l", "--line LINE_NUMBER", Integer, "Execute behaviour or specification at given line.",
                                                        "(does not work for dynamically generated specs)"],
-        :format => ["-f", "--format FORMAT[:WHERE]",  "Specifies what format to use for output. Specify WHERE to tell",
+        :format => ["-f", "--format FORMAT[:WHERE]","Specifies what format to use for output. Specify WHERE to tell",
                                                     "the formatter where to write the output. All built-in formats",
-                                                    "expect WHERE to be a file name, and will write to STDOUT if it's",
+                                                    "expect WHERE to be a file name, and will write to $stdout if it's",
                                                     "not specified. The --format option may be specified several times",
                                                     "if you want several outputs",
                                                     " ",
-                                                    "Builtin formats for examples: ",
-                                                    "progress|p               : Text progress",
-                                                    "profile|o                : Text progress with profiling of 10 slowest examples",
-                                                    "specdoc|s                : Example doc as text",
+                                                    "Builtin formats for code examples:",
+                                                    "progress|p               : Text-based progress bar",
+                                                    "profile|o                : Text-based progress bar with profiling of 10 slowest examples",
+                                                    "specdoc|s                : Code example doc strings",
+                                                    "nested|n                 : Code example doc strings with nested groups intented",
                                                     "html|h                   : A nice HTML report",
                                                     "failing_examples|e       : Write all failing examples - input for --example",
                                                     "failing_example_groups|g : Write all failing example groups - input for --example",
                                                     " ",
-                                                    "Builtin formats for stories: ",
-                                                    "plain|p              : Plain Text",
-                                                    "html|h               : A nice HTML report",
+                                                    "Builtin formats for stories:",
+                                                    "plain|p                  : Plain Text",
+                                                    "html|h                   : A nice HTML report",
+                                                    "progress|r               : Text progress",
                                                     " ",
                                                     "FORMAT can also be the name of a custom formatter class",
                                                     "(in which case you should also specify --require to load it)"],
         :require => ["-r", "--require FILE", "Require FILE before running specs",
-                                          "Useful for loading custom formatters or other extensions.",
-                                          "If this option is used it must come before the others"],
+                                             "Useful for loading custom formatters or other extensions.",
+                                             "If this option is used it must come before the others"],
         :backtrace => ["-b", "--backtrace", "Output full backtrace"],
         :loadby => ["-L", "--loadby STRATEGY", "Specify the strategy by which spec files should be loaded.",
-                                              "STRATEGY can currently only be 'mtime' (File modification time)",
-                                              "By default, spec files are loaded in alphabetical order if --loadby",
-                                              "is not specified."],
+                                               "STRATEGY can currently only be 'mtime' (File modification time)",
+                                               "By default, spec files are loaded in alphabetical order if --loadby",
+                                               "is not specified."],
         :reverse => ["-R", "--reverse", "Run examples in reverse order"],
         :timeout => ["-t", "--timeout FLOAT", "Interrupt and fail each example that doesn't complete in the",
                                               "specified time"],
@@ -92,33 +94,31 @@ module Spec
 
         self.banner = "Usage: spec (FILE|DIRECTORY|GLOB)+ [options]"
         self.separator ""
-        on(*OPTIONS[:pattern]) {|pattern| @options.filename_pattern = pattern}
-        on(*OPTIONS[:diff]) {|diff| @options.parse_diff(diff)}
-        on(*OPTIONS[:colour]) {@options.colour = true}
-        on(*OPTIONS[:example]) {|example| @options.parse_example(example)}
-        on(*OPTIONS[:specification]) {|example| @options.parse_example(example)}
-        on(*OPTIONS[:line]) {|line_number| @options.line_number = line_number.to_i}
-        on(*OPTIONS[:format]) {|format| @options.parse_format(format)}
-        on(*OPTIONS[:require]) {|requires| invoke_requires(requires)}
-        on(*OPTIONS[:backtrace]) {@options.backtrace_tweaker = NoisyBacktraceTweaker.new}
-        on(*OPTIONS[:loadby]) {|loadby| @options.loadby = loadby}
-        on(*OPTIONS[:reverse]) {@options.reverse = true}
-        on(*OPTIONS[:timeout]) {|timeout| @options.timeout = timeout.to_f}
-        on(*OPTIONS[:heckle]) {|heckle| @options.load_heckle_runner(heckle)}
-        on(*OPTIONS[:dry_run]) {@options.dry_run = true}
-        on(*OPTIONS[:options_file]) {|options_file| parse_options_file(options_file)}
-        on(*OPTIONS[:generate_options]) do |options_file|
-        end
-        on(*OPTIONS[:runner]) do |runner|
-          @options.user_input_for_runner = runner
-        end
-        on(*OPTIONS[:drb]) {}
-        on(*OPTIONS[:version]) {parse_version}
-        on_tail(*OPTIONS[:help]) {parse_help}
+        on(*OPTIONS[:pattern])          {|pattern| @options.filename_pattern = pattern}
+        on(*OPTIONS[:diff])             {|diff| @options.parse_diff(diff)}
+        on(*OPTIONS[:colour])           {@options.colour = true}
+        on(*OPTIONS[:example])          {|example| @options.parse_example(example)}
+        on(*OPTIONS[:specification])    {|example| @options.parse_example(example)}
+        on(*OPTIONS[:line])             {|line_number| @options.line_number = line_number.to_i}
+        on(*OPTIONS[:format])           {|format| @options.parse_format(format)}
+        on(*OPTIONS[:require])          {|requires| invoke_requires(requires)}
+        on(*OPTIONS[:backtrace])        {@options.backtrace_tweaker = NoisyBacktraceTweaker.new}
+        on(*OPTIONS[:loadby])           {|loadby| @options.loadby = loadby}
+        on(*OPTIONS[:reverse])          {@options.reverse = true}
+        on(*OPTIONS[:timeout])          {|timeout| @options.timeout = timeout.to_f}
+        on(*OPTIONS[:heckle])           {|heckle| @options.load_heckle_runner(heckle)}
+        on(*OPTIONS[:dry_run])          {@options.dry_run = true}
+        on(*OPTIONS[:options_file])     {|options_file| parse_options_file(options_file)}
+        on(*OPTIONS[:generate_options]) {|options_file|}
+        on(*OPTIONS[:runner])           {|runner|  @options.user_input_for_runner = runner}
+        on(*OPTIONS[:drb])              {}
+        on(*OPTIONS[:version])          {parse_version}
+        on_tail(*OPTIONS[:help])        {parse_help}
       end
 
       def order!(argv, &blk)
-        @argv = argv
+        @argv = argv.dup
+        @argv = (@argv.empty? && Spec.spec_command?) ? ['--help'] : @argv 
         @options.argv = @argv.dup
         return if parse_generate_options
         return if parse_drb
@@ -130,7 +130,7 @@ module Spec
 
         @options
       end
-
+      
       protected
       def invoke_requires(requires)
         requires.split(",").each do |file|
@@ -141,6 +141,10 @@ module Spec
       def parse_options_file(options_file)
         option_file_args = IO.readlines(options_file).map {|l| l.chomp.split " "}.flatten
         @argv.push(*option_file_args)
+        # TODO - this is a brute force solution to http://rspec.lighthouseapp.com/projects/5645/tickets/293.
+        # Let's look for a cleaner way. Might not be one. But let's look. If not, perhaps
+        # this can be moved to a different method to indicate the special handling for drb?
+        parse_drb(@argv)
       end
 
       def parse_generate_options
@@ -170,12 +174,12 @@ module Spec
         @options.examples_should_not_be_run
       end
 
-      def parse_drb
+      def parse_drb(argv = nil)
+        argv ||= @options.argv # TODO - see note about about http://rspec.lighthouseapp.com/projects/5645/tickets/293
         is_drb = false
-        argv = @options.argv
         is_drb ||= argv.delete(OPTIONS[:drb][0])
         is_drb ||= argv.delete(OPTIONS[:drb][1])
-        return nil unless is_drb
+        return false unless is_drb
         @options.examples_should_not_be_run
         DrbCommandLine.run(
           self.class.parse(argv, @error_stream, @out_stream)
@@ -184,7 +188,7 @@ module Spec
       end
 
       def parse_version
-        @out_stream.puts ::Spec::VERSION::DESCRIPTION
+        @out_stream.puts ::Spec::VERSION::SUMMARY
         exit if stdout?
       end