cucumber 0.2.0 → 0.2.1

data/lib/cucumber/cli/main.rb

@@ -32,13 +32,6 @@ module Cucumber
         step_mother.options = configuration.options
 
         require_files
-
-        if(configuration.print_step_definitions?)
-          step_mother.print_step_definitions(@out_stream)
-          Kernel.exit(0)
-          return # In specs, exit is stubbed
-        end
-        
         enable_diffing
       
         features = load_plain_text_features
@@ -53,7 +46,18 @@ module Cucumber
         Kernel.exit(failure ? 1 : 0)
       end
 
-      private
+      def load_plain_text_features
+        features = Ast::Features.new
+        parser = Parser::FeatureParser.new
+
+        verbose_log("Features:")
+        configuration.feature_files.each do |f|
+          features.add_feature(parser.parse_file(f))
+          verbose_log("  * #{f}")
+        end
+        verbose_log("\n"*2)
+        features
+      end
 
       def configuration
         return @configuration if @configuration
@@ -62,6 +66,8 @@ module Cucumber
         @configuration.parse!(@args)
         @configuration
       end
+
+      private
     
       def require_files
         verbose_log("Ruby files required:")
@@ -77,19 +83,6 @@ module Cucumber
         verbose_log("\n")
       end
 
-      def load_plain_text_features
-        features = Ast::Features.new
-        parser = Parser::FeatureParser.new
-
-        verbose_log("Features:")
-        configuration.feature_files.each do |f|
-          features.add_feature(parser.parse_file(f))
-          verbose_log("  * #{f}")
-        end
-        verbose_log("\n"*2)
-        features
-      end
-
       def verbose_log(string)
         @out_stream.puts(string) if configuration.verbose?
       end

data/lib/cucumber/formatter.rb

@@ -1 +1 @@
-%w{color_io pretty progress profile rerun html}.each{|n| require "cucumber/formatter/#{n}"}
+%w{color_io pretty progress profile rerun html usage}.each{|n| require "cucumber/formatter/#{n}"}

data/lib/cucumber/formatter/html.rb

@@ -83,37 +83,73 @@ module Cucumber
         @builder.h4("#{keyword} #{name}")
       end
 
-      def visit_steps(scenarios)
+      def visit_steps(steps)
         @builder.ol do
           super
         end
       end
 
+      def visit_step(step)
+        @step_id = step.dom_id
+        @builder.li(:id => @step_id) do
+          super
+        end
+      end
+
       def visit_step_name(keyword, step_match, status, source_indent, background)
-        step_name = step_match.format_args(lambda{|param| "<span>#{param}</span>"})
-        @builder.li("#{keyword} #{step_name}", :class => status)
+        @step_matches ||= []
+        @skip_step = @step_matches.index(step_match)
+        @step_matches << step_match
+
+        unless @skip_step
+          step_name = step_match.format_args(lambda{|param| "<span>#{param}</span>"})
+          @builder.div(:class => status) do |div|
+            div << "#{keyword} #{step_name}"
+          end
+        end
+      end
+
+      def visit_exception(exception, status)
+        @builder.pre(format_exception(exception), :class => status)
       end
 
       def visit_multiline_arg(multiline_arg)
+        return if @skip_step
         if Ast::Table === multiline_arg
           @builder.table do
             super
           end
         else
-          @builder.p do
-            super
-          end
+          super
+        end
+      end
+
+      def visit_py_string(string, status)
+        @builder.pre(:class => status) do |pre|
+          pre << string
         end
       end
 
       def visit_table_row(table_row)
-        @builder.tr do
+        @row_id = table_row.dom_id
+        @col_index = 0
+        @builder.tr(:id => @row_id) do
           super
         end
+        if table_row.exception
+          @builder.tr do
+            @builder.td(:colspan => @col_index.to_s, :class => 'failed') do
+              @builder.pre do |pre|
+                pre << format_exception(table_row.exception)
+              end
+            end
+          end
+        end
       end
 
       def visit_table_cell_value(value, width, status)
-        @builder.td(value, :class => status)
+        @builder.td(value, :class => status, :id => "#{@row_id}_#{@col_index}")
+        @col_index += 1
       end
 
       def announce(announcement)
@@ -128,6 +164,9 @@ module Cucumber
         end
       end
 
+      def format_exception(exception)
+        (["#{exception.message} (#{exception.class})"] + exception.backtrace).join("\n")
+      end
     end
   end
 end

data/lib/cucumber/formatter/pretty.rb

@@ -121,16 +121,15 @@ module Cucumber
 
       def visit_step_name(keyword, step_match, status, source_indent, background)
         @step_matches ||= []
-        
         non_failed_background_step_outside_background = !@in_background && background && (status != :failed)
         @skip_step = @step_matches.index(step_match) || non_failed_background_step_outside_background
+        @step_matches << step_match
         
         unless(@skip_step)
           source_indent = nil unless @options[:source]
           formatted_step_name = format_step(keyword, step_match, status, source_indent)
           @io.puts("    " + formatted_step_name)
         end
-        @step_matches << step_match
       end
 
       def visit_multiline_arg(multiline_arg)

data/lib/cucumber/formatter/rerun.rb

@@ -1,5 +1,13 @@
 module Cucumber
   module Formatter
+    # This formatter keeps track of all failing features and print out their location.
+    # Example:
+    #
+    #   features/foo.feature:34 features/bar.feature:11:76:81
+    #
+    # This formatter is used by AutoTest - it will use the output to decide what
+    # to run the next time, simply passing the output string on the command line.
+    #
     class Rerun < Ast::Visitor
       def initialize(step_mother, io, options)
         super(step_mother)

data/lib/cucumber/formatter/usage.rb

@@ -0,0 +1,69 @@
+require 'cucumber/formatter/progress'
+
+module Cucumber
+  module Formatter
+    class Usage < Ast::Visitor
+      include Console
+
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @io = io
+        @options = options
+        @step_definitions = Hash.new { |h,step_definition| h[step_definition] = [] }
+        @locations = []
+      end
+
+      def visit_features(features)
+        super
+        print_summary
+      end
+
+      def visit_step(step)
+        @step = step
+        super
+      end
+
+      def visit_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]
+        end
+      end
+
+      def print_summary
+        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.inspect
+          end
+
+          step_matches = step_matches_and_descriptions.map{|step_match_and_description| step_match_and_description[0]}
+
+          lengths = step_matches_and_descriptions.map do |step_match_and_description| 
+            step_match_and_description[2]
+          end
+          lengths << step_definition.text_length
+          max_length = lengths.max
+
+          @io.print step_definition.regexp.inspect
+          @io.puts format_string("   # #{step_definition.file_colon_line}".indent(max_length - step_definition.text_length), :comment)
+          step_matches_and_descriptions.each 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]
+            @io.print " #{description}"
+            @io.puts format_string(" # #{file_colon_line}".indent(max_length - length), :comment)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/jbehave.rb

@@ -27,6 +27,7 @@ if defined?(JRUBY_VERSION)
         end
 
         def step_match(name_to_match, name_to_report)
+          raise "FIXME"
           if(match = name_to_match.match(@regexp))
             StepMatch.new(self, name_to_match, name_to_report, match.captures)
           else

data/lib/cucumber/rails/world.rb

@@ -9,22 +9,10 @@ else
 end
 require 'test/unit/testresult'
 
-# These allow exceptions to come through as opposed to being caught and having non-helpful responses returned.
-ActionController::Base.class_eval do
-  def rescue_action(exception)
-    raise exception
-  end
-end
-ActionController::Dispatcher.class_eval do
-  def self.failsafe_response(output, status, exception = nil)
-    raise exception
-  end
-end
-
 # So that Test::Unit doesn't launch at the end - makes it think it has already been run.
 Test::Unit.run = true if Test::Unit.respond_to?(:run=)
 
-$cucumber_toplevel = self
+$__cucumber_toplevel = self
 
 module Cucumber #:nodoc:
   module Rails
@@ -44,20 +32,21 @@ module Cucumber #:nodoc:
     def self.use_transactional_fixtures
       World.use_transactional_fixtures = true
       if defined?(ActiveRecord::Base)
-        $cucumber_toplevel.Before do
-          if ActiveRecord::Base.connection.respond_to?(:increment_open_transactions)
-            ActiveRecord::Base.connection.increment_open_transactions
+        $__cucumber_toplevel.Before do
+          @__cucumber_ar_connection = ActiveRecord::Base.connection
+          if @__cucumber_ar_connection.respond_to?(:increment_open_transactions)
+            @__cucumber_ar_connection.increment_open_transactions
           else
             ActiveRecord::Base.__send__(:increment_open_transactions)
           end
-          ActiveRecord::Base.connection.begin_db_transaction
+          @__cucumber_ar_connection.begin_db_transaction
           ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
         end
         
-        $cucumber_toplevel.After do
-          ActiveRecord::Base.connection.rollback_db_transaction
-          if ActiveRecord::Base.connection.respond_to?(:decrement_open_transactions)
-            ActiveRecord::Base.connection.decrement_open_transactions
+        $__cucumber_toplevel.After do
+          @__cucumber_ar_connection.rollback_db_transaction
+          if @__cucumber_ar_connection.respond_to?(:decrement_open_transactions)
+            @__cucumber_ar_connection.decrement_open_transactions
           else
             ActiveRecord::Base.__send__(:decrement_open_transactions)
           end
@@ -65,6 +54,18 @@ module Cucumber #:nodoc:
       end
     end
 
+    def self.bypass_rescue
+      ActionController::Base.class_eval do
+        def rescue_action(exception)
+          raise exception
+        end
+      end
+      ActionController::Dispatcher.class_eval do
+        def self.failsafe_response(output, status, exception = nil)
+          raise exception
+        end
+      end
+    end
   end
 end
 

data/lib/cucumber/step_definition.rb

@@ -3,6 +3,50 @@ require 'cucumber/core_ext/string'
 require 'cucumber/core_ext/proc'
 
 module Cucumber
+  module StepDefinitionMethods
+    def step_match(name_to_match, name_to_report)
+      if(match = name_to_match.match(regexp))
+        StepMatch.new(self, name_to_match, name_to_report, match.captures)
+      else
+        nil
+      end
+    end
+
+    # Formats the matched arguments of the associated Step. This method
+    # is usually called from visitors, which render output.
+    #
+    # The +format+ can either be a String or a Proc.
+    #
+    # If it is a String it should be a format string according to
+    # <tt>Kernel#sprinf</tt>, for example:
+    #
+    #   '<span class="param">%s</span></tt>'
+    #
+    # If it is a Proc, it should take one argument and return the formatted
+    # argument, for example:
+    #
+    #   lambda { |param| "[#{param}]" }
+    #
+    def format_args(step_name, format)
+      step_name.gzub(regexp, format)
+    end
+
+    def match(step_name)
+      case step_name
+      when String then regexp.match(step_name)
+      when Regexp then regexp == step_name
+      end
+    end
+
+    def backtrace_line
+      "#{file_colon_line}:in `#{regexp.inspect}'"
+    end
+
+    def text_length
+      regexp.inspect.jlength
+    end
+  end
+  
   # A Step Definition holds a Regexp and a Proc, and is created
   # by calling <tt>Given</tt>, <tt>When</tt> or <tt>Then</tt>
   # in the <tt>step_definitions</tt> ruby files - for example:
@@ -14,7 +58,22 @@ module Cucumber
   class StepDefinition
     def self.snippet_text(step_keyword, step_name)
       escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
-      "#{step_keyword} /^#{escaped}$/ do\n  pending\nend"
+      param_pattern = /"([^\"]*)"/
+
+      match = escaped.match(param_pattern)
+      if match
+        n = 0
+        block_args = match.captures.map do |a|
+          n += 1
+          "arg#{n}"
+        end
+        block_arg_string = " |#{block_args.join(", ")}|"
+      else
+        block_arg_string = ""
+      end
+
+      escaped = escaped.gsub(param_pattern, '"([^\\"]*)"')
+      "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  pending\nend"
     end
 
     class MissingProc < StandardError
@@ -23,7 +82,7 @@ module Cucumber
       end
     end
 
-    attr_reader :regexp
+    include StepDefinitionMethods
 
     def initialize(pattern, &proc)
       raise MissingProc if proc.nil?
@@ -34,70 +93,22 @@ module Cucumber
       @regexp, @proc = pattern, proc
     end
 
-    def step_match(name_to_match, name_to_report)
-      if(match = name_to_match.match(@regexp))
-        StepMatch.new(self, name_to_match, name_to_report, match.captures)
-      else
-        nil
-      end
+    def regexp
+      @regexp
     end
 
-    def invoke(world, args, step_name)
+    def invoke(world, args)
       args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
       begin
-        world.cucumber_instance_exec(true, @regexp.inspect, *args, &@proc)
+        world.cucumber_instance_exec(true, regexp.inspect, *args, &@proc)
       rescue Cucumber::ArityMismatchError => e
         e.backtrace.unshift(self.backtrace_line)
         raise e
       end
     end
 
-    #:stopdoc:
-
-    def match(step_name)
-      case step_name
-      when String then @regexp.match(step_name)
-      when Regexp then @regexp == step_name
-      end
-    end
-
-    # Formats the matched arguments of the associated Step. This method
-    # is usually called from visitors, which render output.
-    #
-    # The +format+ either be a String or a Proc.
-    #
-    # If it is a String it should be a format string according to
-    # <tt>Kernel#sprinf</tt>, for example:
-    #
-    #   '<span class="param">%s</span></tt>'
-    #
-    # If it is a Proc, it should take one argument and return the formatted
-    # argument, for example:
-    #
-    #   lambda { |param| "[#{param}]" }
-    #
-    def format_args(step_name, format)
-      step_name.gzub(@regexp, format)
-    end
-
-    def matched_args(step_name)
-      step_name.match(@regexp).captures
-    end
-
-    def backtrace_line
-      "#{file_colon_line}:in `#{@regexp.inspect}'"
-    end
-
     def file_colon_line
       @proc.file_colon_line
     end
-
-    def text_length
-      @regexp.inspect.jlength
-    end
-
-    def to_s(indent = 0)
-      @regexp.inspect + (' # ').indent(indent) + file_colon_line
-    end
   end
 end