aslakhellesoy-cucumber 0.3.103 → 0.3.104

data/lib/cucumber/ast/tree_walker.rb

@@ -0,0 +1,179 @@
+module Cucumber
+  module Ast
+    # Walks the AST, executing steps and notifying listeners
+    class TreeWalker
+      attr_accessor :options #:nodoc:
+      attr_reader   :step_mother #:nodoc:
+
+      def initialize(step_mother, listeners = [], options = {}, io = STDOUT)
+        @step_mother, @listeners, @options, @io = step_mother, listeners, options, io
+      end
+
+      def visit_features(features)
+        broadcast(features) do
+          features.accept(self)
+        end
+      end
+
+      def visit_feature(feature)
+        broadcast(feature) do
+          feature.accept(self)
+        end
+      end
+
+      def visit_comment(comment)
+        broadcast(comment) do
+          comment.accept(self)
+        end
+      end
+
+      def visit_comment_line(comment_line)
+        broadcast(comment_line)
+      end
+
+      def visit_tags(tags)
+        broadcast(tags) do
+          tags.accept(self)
+        end
+      end
+
+      def visit_tag_name(tag_name)
+        broadcast(tag_name)
+      end
+
+      def visit_feature_name(name)
+        broadcast(name)
+      end
+
+      # +feature_element+ is either Scenario or ScenarioOutline
+      def visit_feature_element(feature_element)
+        broadcast(feature_element) do
+          feature_element.accept(self)
+        end
+      end
+
+      def visit_background(background)
+        broadcast(background) do
+          background.accept(self)
+        end
+      end
+
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+        broadcast(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_examples_array(examples_array)
+        broadcast(examples_array) do
+          examples_array.accept(self)
+        end
+      end
+
+      def visit_examples(examples)
+        broadcast(examples) do
+          examples.accept(self)
+        end
+      end
+
+      def visit_examples_name(keyword, name)
+        broadcast(keyword, name)
+      end
+
+      def visit_outline_table(outline_table)
+        broadcast(outline_table) do
+          outline_table.accept(self)
+        end
+      end
+
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+        broadcast(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_steps(steps)
+        broadcast(steps) do
+          steps.accept(self)
+        end
+      end
+
+      def visit_step(step)
+        broadcast(step) do
+          step.accept(self)
+        end
+      end
+
+      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        broadcast(keyword, step_match, multiline_arg, status, exception, source_indent, background) do
+          visit_step_name(keyword, step_match, status, source_indent, background)
+          visit_multiline_arg(multiline_arg) if multiline_arg
+          visit_exception(exception, status) if exception
+        end
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background) #:nodoc:
+        broadcast(keyword, step_match, status, source_indent, background)
+      end
+
+      def visit_multiline_arg(multiline_arg) #:nodoc:
+        broadcast(multiline_arg) do
+          multiline_arg.accept(self)
+        end
+      end
+
+      def visit_exception(exception, status) #:nodoc:
+        broadcast(exception, status)
+      end
+
+      def visit_py_string(string)
+        broadcast(string)
+      end
+
+      def visit_table_row(table_row)
+        broadcast(table_row) do
+          table_row.accept(self)
+        end
+      end
+
+      def visit_table_cell(table_cell)
+        broadcast(table_cell) do
+          table_cell.accept(self)
+        end
+      end
+
+      def visit_table_cell_value(value, status)
+        broadcast(value, status)
+      end
+
+      # Print +announcement+. This method can be called from within StepDefinitions.
+      def announce(announcement)
+        broadcast(announcement)
+      end
+      
+      private
+      
+      def broadcast(*args, &block)
+        message = extract_method_name_from(caller)
+        message.gsub!('visit_', '')
+        
+        if block_given?
+          send_to_all("before_#{message}", *args)
+          yield if block_given?
+          send_to_all("after_#{message}", *args)
+        else
+          send_to_all(message, *args)
+        end
+      end
+      
+      def send_to_all(message, *args)
+        @listeners.each do |listener|
+          if listener.respond_to?(message)
+            listener.__send__(message, *args)
+          end
+        end
+      end
+      
+      def extract_method_name_from(call_stack)
+        call_stack[0].match(/in `(.*)'/).captures[0]
+      end
+      
+    end
+  end
+end

data/lib/cucumber/cli/options.rb

@@ -9,13 +9,17 @@ module Cucumber
         'pdf'       => ['Cucumber::Formatter::Pdf',      "Generates a PDF report. You need to have the\n" + 
                                                          "#{' ' * 51}prawn gem installed. Will pick up logo from\n" + 
                                                          "#{' ' * 51}features/support/logo.png if present."],
-        'profile'   => ['Cucumber::Formatter::Profile',  'Prints the 10 slowest steps at the end.'],
         'progress'  => ['Cucumber::Formatter::Progress', 'Prints one character per scenario.'],
         'rerun'     => ['Cucumber::Formatter::Rerun',    'Prints failing files with line numbers.'],
-        'usage'     => ['Cucumber::Formatter::Usage',    'Prints where step definitions are used.'],
+        'usage'     => ['Cucumber::Formatter::Usage',    "Prints where step definitions are used.\n" +
+                                                         "#{' ' * 51}The slowest step definitions (with duration) are\n" + 
+                                                         "#{' ' * 51}listed first. If --dry-run is used the duration\n" +
+                                                         "#{' ' * 51}is not shown, and step definitions are sorted by\n" +
+                                                         "#{' ' * 51}filename instead."],
+        'stepdefs'  => ['Cucumber::Formatter::Stepdefs', "Prints All step definitions with their locations. Same as\n" +
+                                                         "the usage formatter, except that steps are not printed."],
         'junit'     => ['Cucumber::Formatter::Junit',    'Generates a report similar to Ant+JUnit.'],
-        'tag_cloud' => ['Cucumber::Formatter::TagCloud', 'Prints a tag cloud of tag usage.'],
-        'steps'     => ['Cucumber::Formatter::Steps',    'Prints location of step definitions.']
+        'tag_cloud' => ['Cucumber::Formatter::TagCloud', 'Prints a tag cloud of tag usage.']
       }
       max = BUILTIN_FORMATS.keys.map{|s| s.length}.max
       FORMAT_HELP = (BUILTIN_FORMATS.keys.sort.map do |key|
@@ -171,9 +175,9 @@ module Cucumber
           end
           opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.",
             "This also omits the loading of your support/env.rb file if it exists.",
-            "Implies --quiet.") do
+            "Implies --no-snippets.") do
             @options[:dry_run] = true
-            @quiet = true
+            @options[:snippets] = false
           end
           opts.on("-a", "--autoformat DIRECTORY",
             "Reformats (pretty prints) feature files and write them to DIRECTORY.",
@@ -257,12 +261,16 @@ module Cucumber
       attr_reader :options, :profiles, :expanded_args
       protected :options, :profiles, :expanded_args
 
-      def non_stdout_formats
-        @options[:formats].select {|format, output| output != @out_stream }
-      end
-
     private
 
+    def non_stdout_formats
+      @options[:formats].select {|format, output| output != @out_stream }
+    end
+
+    def stdout_formats
+      @options[:formats].select {|format, output| output == @out_stream }
+    end
+
      def extract_environment_variables
         @args.delete_if do |arg|
           if arg =~ /^(\w+)=(.*)$/
@@ -337,7 +345,8 @@ module Cucumber
         if @options[:formats].empty?
           @options[:formats] = other_options[:formats]
         else
-          @options[:formats] += other_options.non_stdout_formats
+          @options[:formats] += other_options[:formats]
+          @options[:formats] = stdout_formats[0..0] + non_stdout_formats
         end
 
         self

data/lib/cucumber/formatter/html.rb

@@ -1,7 +1,5 @@
 require 'cucumber/formatter/ordered_xml_markup'
 require 'cucumber/formatter/duration'
-require 'xml'
-require 'ruby-debug'
 
 module Cucumber
   module Formatter

data/lib/cucumber/formatter/stepdefs.rb

@@ -0,0 +1,14 @@
+require 'cucumber/formatter/usage'
+
+module Cucumber
+  module Formatter
+    class Stepdefs < Usage
+      def print_steps(stepdef_key)
+      end
+
+      def max_step_length
+        0
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/usage.rb

@@ -2,82 +2,138 @@ require 'cucumber/formatter/progress'
 
 module Cucumber
   module Formatter
-    # The formatter used for <tt>--format usage</tt>
-    class Usage
+    class Usage < Progress
       include Console
 
+      class StepDefKey
+        attr_reader :regexp_source, :file_colon_line
+        attr_accessor :mean_duration, :status
+        
+        def initialize(regexp_source, file_colon_line)
+          @regexp_source, @file_colon_line = regexp_source, file_colon_line
+        end
+        
+        def eql?(o)
+          regexp_source == o.regexp_source && file_colon_line == o.file_colon_line
+        end
+        
+        def hash
+          regexp_source.hash + 17*file_colon_line.hash
+        end
+      end
+
       def initialize(step_mother, io, options)
+        @step_mother = step_mother
         @io = io
         @options = options
-        @step_definitions = Hash.new { |h,step_definition| h[step_definition] = [] }
-        @all_step_definitions = step_mother.step_definitions.dup
-        @locations = []
-      end
-
-      def after_features(features)
-        print_summary(features)
+        @stepdef_to_match = Hash.new{|h,stepdef_key| h[stepdef_key] = []}
       end
 
       def before_step(step)
         @step = step
       end
 
-      def step_name(keyword, step_match, status, source_indent, background)
-        if step_match.step_definition
-          location = @step.file_colon_line
-          return if @locations.index(location)
-          @locations << location
-          
-          description = format_step(keyword, step_match, status, nil)
-          length = (keyword + step_match.format_args).jlength
-          @step_definitions[step_match.step_definition] << [step_match, description, length, location]
-          @all_step_definitions.delete(step_match.step_definition)
+      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        @step_duration = Time.now
+      end
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        duration = Time.now - @step_duration
+        if step_match.name.nil? # nil if it's from a scenario outline
+          stepdef_key = StepDefKey.new(step_match.step_definition.regexp_source, step_match.step_definition.file_colon_line)
+
+          @stepdef_to_match[stepdef_key] << {
+            :keyword => keyword, 
+            :step_match => step_match, 
+            :status => status, 
+            :file_colon_line => @step.file_colon_line,
+            :duration => duration
+          }
         end
+        super
       end
 
       def print_summary(features)
-        sorted_defs = @step_definitions.keys.sort_by{|step_definition| step_definition.backtrace_line}
-        
-        sorted_defs.each do |step_definition|          
-          step_matches_and_descriptions = @step_definitions[step_definition].sort_by do |step_match_and_description|
-            step_match = step_match_and_description[0]
-            step_match.step_definition.regexp_source
-          end
+        add_unused_stepdefs
+        aggregate_info
 
-          step_matches = step_matches_and_descriptions.map{|step_match_and_description| step_match_and_description[0]}
+        if @options[:dry_run]
+          keys = @stepdef_to_match.keys.sort {|a,b| a.regexp_source <=> b.regexp_source}
+        else
+          keys = @stepdef_to_match.keys.sort {|a,b| a.mean_duration <=> b.mean_duration}.reverse
+        end
+
+        keys.each do |stepdef_key|
+          print_step_definition(stepdef_key)
 
-          lengths = step_matches_and_descriptions.map do |step_match_and_description| 
-            step_match_and_description[2]
+          if @stepdef_to_match[stepdef_key].any?
+            print_steps(stepdef_key)
+          else
+            @io.puts("  " + format_string("NOT MATCHED BY ANY STEPS", :failed))
           end
-          lengths << step_definition.text_length
-          max_length = lengths.max
-
-          @io.print step_definition.regexp_source
-          @io.puts format_string("   # #{step_definition.file_colon_line}".indent(max_length - step_definition.text_length), :comment)
-          da = step_matches_and_descriptions.map do |step_match_and_description|
-            step_match      = step_match_and_description[0]
-            description     = step_match_and_description[1]
-            length          = step_match_and_description[2]
-            file_colon_line = step_match_and_description[3]
-            " #{description}" + format_string(" # #{file_colon_line}".indent(max_length - length), :comment)
+        end
+        @io.puts
+        super
+      end
+
+      def print_step_definition(stepdef_key)
+        @io.print format_string(sprintf("%.7f", stepdef_key.mean_duration), :skipped) + " " unless @options[:dry_run]
+        @io.print format_string(stepdef_key.regexp_source, stepdef_key.status)
+        if @options[:source]
+          indent = max_length - stepdef_key.regexp_source.jlength
+          line_comment = "    # #{stepdef_key.file_colon_line}".indent(indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+      end
+
+      def print_steps(stepdef_key)
+        @stepdef_to_match[stepdef_key].each do |step|
+          @io.print "  "
+          @io.print format_string(sprintf("%.7f", step[:duration]), :skipped) + " " unless @options[:dry_run]
+          @io.print format_step(step[:keyword], step[:step_match], step[:status], nil)
+          if @options[:source]
+            indent = max_length - (step[:keyword].jlength + step[:step_match].format_args.jlength)
+            line_comment = " # #{step[:file_colon_line]}".indent(indent)
+            @io.print(format_string(line_comment, :comment))
           end
-          da.sort.each{|d| puts d}
+          @io.puts
         end
+      end
+
+      def max_length
+        [max_stepdef_length, max_step_length].compact.max
+      end
 
-        print_unused_step_definitions
+      def max_stepdef_length
+        @stepdef_to_match.keys.flatten.map{|key| key.regexp_source.jlength}.max
       end
 
-      def print_unused_step_definitions
-        if @all_step_definitions.any?
-          max_length = @all_step_definitions.map{|step_definition| step_definition.text_length}.max
+      def max_step_length
+        @stepdef_to_match.values.flatten.map do |step|
+          step[:keyword].jlength + step[:step_match].format_args.jlength
+        end.max
+      end
 
-          @io.puts format_string("(::) UNUSED (::)", :failed)
-          @all_step_definitions.each do |step_definition|
-            @io.print format_string(step_definition.regexp_source, :failed)
-            @io.puts format_string("  # #{step_definition.file_colon_line}".indent(max_length - step_definition.text_length), :comment)
+      def aggregate_info
+        @stepdef_to_match.each do |key, steps|
+          if steps.empty?
+            key.status = :skipped
+            key.mean_duration = 0
+          else
+            key.status = Ast::StepInvocation.worst_status(steps.map{|step| step[:status]})
+            total_duration = steps.inject(0) {|sum, step| step[:duration] + sum}
+            key.mean_duration = total_duration / steps.length
           end
         end
       end
+
+      def add_unused_stepdefs
+        @step_mother.unmatched_step_definitions.each do |step_definition|
+          stepdef_key = StepDefKey.new(step_definition.regexp_source, step_definition.file_colon_line)
+          @stepdef_to_match[stepdef_key] = []
+        end
+      end
     end
   end
-end
+end