cucumber 0.3.103 → 0.3.104

data/lib/cucumber/ast/tree_walker.rb

@@ -10,7 +10,6 @@ module Cucumber
       end
 
       def visit_features(features)
-        warn "The listener(s) (#{deprecated_listeners.map{ |l| l.class }}) appear to support the legacy Ast::Visitor interface, which is no longer supported." if deprecated_listeners.any?
         broadcast(features) do
           features.accept(self)
         end
@@ -154,14 +153,13 @@ module Cucumber
         message = extract_method_name_from(caller)
         message.gsub!('visit_', '')
         
-        unless block_given?
+        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)
-          return
         end
-        
-        send_to_all("before_#{message}", *args)
-        yield if block_given?
-        send_to_all("after_#{message}", *args)
       end
       
       def send_to_all(message, *args)
@@ -176,10 +174,6 @@ module Cucumber
         call_stack[0].match(/in `(.*)'/).captures[0]
       end
       
-      def deprecated_listeners
-        @listeners.select{ |l| l.respond_to?(:visit_features) }
-      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

data/lib/cucumber/language_support/language_methods.rb

@@ -1,6 +1,12 @@
+require 'cucumber/step_match'
+
 module Cucumber
   module LanguageSupport
     module LanguageMethods
+      def create_step_match(step_definition, step_name, formatted_step_name, step_arguments)
+        StepMatch.new(step_definition, step_name, formatted_step_name, step_arguments)
+      end
+      
       def before(scenario)
         begin_scenario
         execute_before(scenario)
@@ -41,15 +47,6 @@ module Cucumber
         transform
       end
 
-      def add_step_definition(step_definition)
-        step_definitions << step_definition
-        step_definition
-      end
-
-      def step_definitions
-        @step_definitions ||= []
-      end
-
       def hooks_for(phase, scenario) #:nodoc:
         hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
       end

data/lib/cucumber/rb_support/rb_language.rb

@@ -34,6 +34,7 @@ module Cucumber
       
       def initialize(step_mother)
         @step_mother = step_mother
+        @step_definitions = []
         RbDsl.rb_language = self
       end
 
@@ -56,10 +57,20 @@ module Cucumber
         end
       end
 
+      def step_matches(step_name, formatted_step_name)
+        @step_definitions.map do |step_definition|
+          step_definition.step_match(step_name, formatted_step_name)
+        end.compact
+      end
+
       def arguments_from(regexp, step_name)
         @regexp_argument_matcher.arguments_from(regexp, step_name)
       end
 
+      def unmatched_step_definitions
+        @step_definitions.select{|step_definition| !step_definition.matched?}
+      end
+
       def snippet_text(step_keyword, step_name, multiline_arg_class = nil)
         escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
         escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
@@ -94,7 +105,9 @@ module Cucumber
       end
 
       def register_rb_step_definition(regexp, proc)
-        add_step_definition(RbStepDefinition.new(self, regexp, proc))
+        step_definition = RbStepDefinition.new(self, regexp, proc)
+        @step_definitions << step_definition
+        step_definition
       end
 
       def build_rb_world_factory(world_modules, proc)
@@ -106,12 +119,12 @@ module Cucumber
         @world_modules += world_modules
       end
 
-      protected
-
       def load_code_file(code_file)
         require code_file # This will cause self.add_step_definition, self.add_hook, and self.add_transform to be called from RbDsl
       end
 
+      protected
+
       def begin_scenario
         begin_rb_scenario
       end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -42,7 +42,9 @@ module Cucumber
       end
 
       def arguments_from(step_name)
-        RegexpArgumentMatcher.arguments_from(@regexp, step_name)
+        args = RegexpArgumentMatcher.arguments_from(@regexp, step_name)
+        @matched = true if args
+        args
       end
 
       def invoke(args)
@@ -56,6 +58,10 @@ module Cucumber
         end
       end
 
+      def matched?
+        @matched
+      end
+
       def file_colon_line
         @proc.file_colon_line
       end

data/lib/cucumber/step_match.rb

@@ -69,6 +69,10 @@ module Cucumber
       end
       s
     end
+
+    def inspect #:nodoc:
+      sprintf("#<%s:0x%x>", self.class, self.object_id)
+    end
   end
   
   class NoStepMatch #:nodoc:

data/lib/cucumber/step_mother.rb

@@ -38,16 +38,6 @@ module Cucumber
     end
   end
 
-  # Raised when 2 or more StepDefinition have the same Regexp
-  class Redundant < StandardError
-    def initialize(step_def_1, step_def_2)
-      message = "Multiple step definitions have the same Regexp:\n\n"
-      message << step_def_1.backtrace_line << "\n"
-      message << step_def_2.backtrace_line << "\n\n"
-      super(message)
-    end
-  end
-
   # This is the meaty part of Cucumber that ties everything together.
   class StepMother
     include Constantize
@@ -87,17 +77,12 @@ module Cucumber
     def load_code_file(step_def_file)
       if programming_language = programming_language_for(step_def_file)
         log.debug("  * #{step_def_file}\n")
-        step_definitions = programming_language.step_definitions_for(step_def_file)
-        register_step_definitions(step_definitions)
+        programming_language.load_code_file(step_def_file)
       else
         log.debug("  * #{step_def_file} [NOT SUPPORTED]\n")
       end
     end
 
-    def register_step_definitions(step_definitions)
-      step_definitions.each{|step_definition| register_step_definition(step_definition)}
-    end
-
     # Loads and registers programming language implementation.
     # Instances are cached, so calling with the same argument
     # twice will return the same instance.
@@ -152,7 +137,9 @@ module Cucumber
     end
 
     def step_match(step_name, formatted_step_name=nil) #:nodoc:
-      matches = step_definitions.map { |d| d.step_match(step_name, formatted_step_name) }.compact
+      matches = @programming_languages.map do |programming_language| 
+        programming_language.step_matches(step_name, formatted_step_name)
+      end.flatten
       raise Undefined.new(step_name) if matches.empty?
       matches = best_matches(step_name, matches) if matches.size > 1 && options[:guess]
       raise Ambiguous.new(step_name, matches, options[:guess]) if matches.size > 1
@@ -174,16 +161,11 @@ module Cucumber
         top_groups
       end
     end
-    
-    def clear! #:nodoc:
-      step_definitions.clear
-      hooks.clear
-      steps.clear
-      scenarios.clear
-    end
 
-    def step_definitions #:nodoc:
-      @step_definitions ||= []
+    def unmatched_step_definitions
+      @programming_languages.map do |programming_language| 
+        programming_language.unmatched_step_definitions
+      end.flatten
     end
 
     def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
@@ -244,17 +226,6 @@ module Cucumber
 
     private
 
-    # Registers a StepDefinition. This can be a Ruby StepDefintion,
-    # or any other kind of object that implements the StepDefintion
-    # contract (API).
-    def register_step_definition(step_definition)
-      step_definitions.each do |already|
-        raise Redundant.new(already, step_definition) if already == step_definition
-      end
-      step_definitions << step_definition
-      step_definition
-    end
-
     def programming_language_for(step_def_file) #:nodoc:
       if ext = File.extname(step_def_file)[1..-1]
         return nil if @unsupported_programming_languages.index(ext)