cucumber 0.3.102 → 0.3.103

data/lib/cucumber/formatter/junit.rb

@@ -3,21 +3,20 @@ require 'cucumber/formatter/ordered_xml_markup'
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format junit</tt>
-    class Junit < Cucumber::Ast::Visitor
-
+    class Junit
       def initialize(step_mother, io, options)
-        super(step_mother)
         raise "You *must* specify --out DIR for the junit formatter" unless String === io && File.directory?(io)
         @reportdir = io
         @options = options
       end
 
-      def visit_feature(feature)
+      def before_feature(feature)
         @failures = @errors = @tests = 0
         @builder = OrderedXmlMarkup.new( :indent => 2 )
         @time = 0
-        super
-
+      end
+      
+      def after_feature(feature)
         @testsuite = OrderedXmlMarkup.new( :indent => 2 )
         @testsuite.instruct!
         @testsuite.testsuite(
@@ -25,7 +24,7 @@ module Cucumber
           :errors => @errors,
           :tests => @tests,
           :time => "%.6f" % @time,
-        :name => @feature_name ) do
+          :name => @feature_name ) do
           @testsuite << @builder.target!
         end
 
@@ -34,18 +33,20 @@ module Cucumber
         File.open(feature_filename, 'w') { |file| file.write(@testsuite.target!) }
       end
 
-      def visit_background(name)
+      def before_background(*args)
         @in_background = true
-        super
+      end
+      
+      def after_background(*args)
         @in_background = false
       end
 
-      def visit_feature_name(name)
+      def feature_name(name)
         lines = name.split(/\r?\n/)
         @feature_name = lines[0].sub(/Feature\:/, '').strip
       end
 
-      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+      def scenario_name(keyword, name, file_colon_line, source_indent)
         scenario_name = name.strip.delete(".\r\n")
         scenario_name = "Unnamed scenario" if name.blank?
         @scenario = scenario_name
@@ -53,11 +54,13 @@ module Cucumber
         @output = "Scenario#{ " outline" if @outline}: #{@scenario}\n\n"
       end
 
-      def visit_steps(steps)
+      def before_steps(steps)
+        @steps_start = Time.now
+      end
+      
+      def after_steps(steps)
         return if @in_background
-        start = Time.now
-        super
-        duration = Time.now - start
+        duration = Time.now - @steps_start
         unless @outline
           if steps.failed?
             steps.each { |step| @output += "#{step.keyword} #{step.name}\n" }
@@ -67,16 +70,21 @@ module Cucumber
         end
       end
 
-      def visit_outline_table(outline_table)
+      def before_outline_table(outline_table)
         @header_row = true
-        super(outline_table)
       end
 
-      def visit_table_row(table_row)
+      def before_table_row(table_row)
+        if @outline
+          @table_start = Time.now
+        end
+        
+        @header_row = false
+      end
+
+      def after_table_row(table_row)
         if @outline
-          start = Time.now
-          super(table_row)
-          duration = Time.now - start
+          duration = Time.now - @table_start
           unless @header_row
             name_suffix = " (outline example : #{table_row.name})"
             if table_row.failed?
@@ -85,8 +93,6 @@ module Cucumber
             end
             build_testcase(duration, table_row.status, table_row.exception,  name_suffix)
           end
-        else
-          super(table_row)
         end
         @header_row = false
       end

data/lib/cucumber/formatter/pdf.rb

@@ -10,13 +10,13 @@ module Cucumber
     BLACK = '000000'
     GREY = '999999'
 
-    class Pdf < Ast::Visitor
+    class Pdf
       include FileUtils
       include Console
       attr_writer :indent
 
       def initialize(step_mother, io, options)
-        super(step_mother)
+        @step_mother = step_mother
         raise "You *must* specify --out FILE for the pdf formatter" unless File === io
 
         if(options[:dry_run])
@@ -53,41 +53,12 @@ module Cucumber
         end
       end
 
-      def keep_with(&block)
-        @buffer << block
-      end
-
-      def render(doc)
-        @doc = doc
-        @buffer.each do |proc|
-          proc.call
-        end
-      end
-
-      # This method does a 'test' rendering on a blank page, to see the rendered height of the buffer
-      # if that too high for the space left on the age in the real document, we do a page break.
-      # This obviously doesn't work if a scenario is longer than a whole page (God forbid)
-      def flush
-        @scrap.start_new_page
-        oldy = @scrap.y
-        render @scrap
-        height = (oldy - @scrap.y) + 36 # whops magic number
-        if ((@pdf.y - height) < @pdf.bounds.bottom)
-          @pdf.start_new_page
-        end
-        render @pdf
-        @pdf.move_down(20)
-        @buffer = []
-      end
-
-      # regular visitor entries
-      def visit_features(features)
-        super
+      def after_features(features)
         @pdf.render_file(@io.path)
         puts "\ndone"
       end
 
-      def visit_feature_name(name)
+      def feature_name(name)
         @pdf.start_new_page
         name["Feature:"] = "" if name["Feature:"]
         names = name.split("\n")
@@ -106,18 +77,19 @@ module Cucumber
         @pdf.move_down(30)
       end
 
-      def visit_feature_element(feature_element)
+      def before_feature_element(feature_element)
         record_tag_occurrences(feature_element, @options)
-        super
+      end
+      
+      def after_feature_element(feature_element)
         flush
       end
 
-      def visit_feature(feature)
-        super
+      def after_feature(feature)
         flush
       end
 
-      def visit_feature_element_name(keyword, name)
+      def feature_element_name(keyword, name)
         names = name.empty? ? [name] : name.split("\n")
         print "."
         STDOUT.flush
@@ -133,53 +105,55 @@ module Cucumber
         end
       end
 
-      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+      def step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        @hide_this_step = false
         if exception
-          return if @exceptions.index(exception)
+          if @exceptions.include?(exception)
+            @hide_this_step = true
+            return
+          end
           @exceptions << exception
         end
-        return if status != :failed && @in_background ^ background
-        @status = status
-        super
-      end
-
-      def colorize(text, status)
-        keep_with do
-          @doc.fill_color(@status_colors[status] || BLACK)
-          @doc.text(text)
-          @doc.fill_color(BLACK)
+        if status != :failed && @in_background ^ background
+          @hide_this_step = true
+          return
         end
       end
 
-      def visit_step_name(keyword, step_match, status, source_indent, background)
+      def step_name(keyword, step_match, status, source_indent, background)
+        return if @hide_this_step
         line = "<b>#{keyword}</b> #{step_match.format_args("%s").gsub('<', '&lt;').gsub('>', '&gt;')}"
         colorize(line, status)
       end
 
-      def visit_background(background)
+      def before_background(background)
         @in_background = true
-        super
+      end
+
+      def after_background(background)
         @in_background = nil
       end
 
-      def visit_multiline_arg(table)
+      def before_multiline_arg(table)
+        return if @hide_this_step
         if(table.kind_of? Cucumber::Ast::Table)
           keep_with do
             @doc.table(table.rows << table.headers , :position => :center, :row_colors => ['ffffff', 'f0f0f0'])
           end
         end
-        super
       end
 
       #using row_color hack to highlight each row correctly
-      def visit_outline_table(table)
+      def before_outline_table(table)
+        return if @hide_this_step
         row_colors = table.example_rows.map { |r| @status_colors[r.status] unless r.status == :skipped}
         keep_with do
           @doc.table(table.rows, :headers => table.headers, :position => :center, :row_colors => row_colors)
         end
       end
 
-      def visit_py_string(string)
+      def before_py_string(string)
+        return if @hide_this_step
         s = %{"""\n#{string}\n"""}.indent(10)
         s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}
         s.each do |line|
@@ -189,28 +163,59 @@ module Cucumber
         end
       end
 
-      def visit_comment(comment)
-        comment.accept(self)
+      def tag_name(tag_name)
+        return if @hide_this_step
+        tag = format_string(tag_name, :tag).indent(@indent)
+        # TODO should we render tags at all? skipped for now. difficult to place due to page breaks
       end
 
-      def visit_comment_line(comment_line)
+      def background_name(keyword, name, file_colon_line, source_indent)
+        feature_element_name(keyword, name)
       end
 
-      def visit_tag_name(tag_name)
-        tag = format_string(tag_name, :tag).indent(@indent)
-        # TODO should we render tags at all? skipped for now. difficult to place due to page breaks
+      def examples_name(keyword, name)
+        feature_element_name(keyword, name)
       end
 
-      def visit_background_name(keyword, name, file_colon_line, source_indent)
-        visit_feature_element_name(keyword, name)
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        feature_element_name(keyword, name)
+      end
+      
+      private
+      
+      def colorize(text, status)
+        keep_with do
+          @doc.fill_color(@status_colors[status] || BLACK)
+          @doc.text(text)
+          @doc.fill_color(BLACK)
+        end
+      end
+      
+      def keep_with(&block)
+        @buffer << block
       end
 
-      def visit_examples_name(keyword, name)
-        visit_feature_element_name(keyword, name)
+      def render(doc)
+        @doc = doc
+        @buffer.each do |proc|
+          proc.call
+        end
       end
 
-      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
-        visit_feature_element_name(keyword, name)
+      # This method does a 'test' rendering on a blank page, to see the rendered height of the buffer
+      # if that too high for the space left on the age in the real document, we do a page break.
+      # This obviously doesn't work if a scenario is longer than a whole page (God forbid)
+      def flush
+        @scrap.start_new_page
+        oldy = @scrap.y
+        render @scrap
+        height = (oldy - @scrap.y) + 36 # whops magic number
+        if ((@pdf.y - height) < @pdf.bounds.bottom)
+          @pdf.start_new_page
+        end
+        render @pdf
+        @pdf.move_down(20)
+        @buffer = []
       end
     end
   end

data/lib/cucumber/formatter/pretty.rb

@@ -10,191 +10,192 @@ module Cucumber
     #
     # If the output is STDOUT (and not a file), there are bright colours to watch too.
     #
-    class Pretty < Ast::Visitor
+    class Pretty
       include FileUtils
       include Console
       attr_writer :indent
+      attr_reader :step_mother
 
       def initialize(step_mother, io, options)
-        super(step_mother)
-        @io = io
-        @options = options
+        @step_mother, @io, @options = step_mother, io, options
         @exceptions = []
         @indent = 0
         @prefixes = options[:prefixes] || {}
       end
 
-      def visit_features(features)
-        super
+      def after_features(features)
         print_summary(features) unless @options[:autoformat]
       end
 
-      def visit_feature(feature)
+      def before_feature(feature)
         @exceptions = []
         @indent = 0
         if @options[:autoformat]
           file = File.join(@options[:autoformat], feature.file)
           dir = File.dirname(file)
           mkdir_p(dir) unless File.directory?(dir)
-          File.open(file, Cucumber.file_mode('w')) do |io|
-            @io = io
-            super
-          end
-        else
-          super
+          @io = File.open(file, Cucumber.file_mode('w'))
         end
       end
-
-      def visit_comment(comment)
-        comment.accept(self)
+      
+      def after_feature(*args)
+        @io.close if @options[:autoformat]
       end
 
-      def visit_comment_line(comment_line)
+      def comment_line(comment_line)
         @io.puts(comment_line.indent(@indent))
         @io.flush
       end
 
-      def visit_tags(tags)
-        tags.accept(self)
+      def after_tags(tags)
         if @indent == 1
           @io.puts
           @io.flush
         end
       end
 
-      def visit_tag_name(tag_name)
+      def tag_name(tag_name)
         tag = format_string(tag_name, :tag).indent(@indent)
         @io.print(tag)
         @io.flush
         @indent = 1
       end
 
-      def visit_feature_name(name)
+      def feature_name(name)
         @io.puts(name)
         @io.puts
         @io.flush
       end
 
-      def visit_feature_element(feature_element)
+      def before_feature_element(feature_element)
         record_tag_occurrences(feature_element, @options)
         @indent = 2
         @scenario_indent = 2
-        super
+      end
+      
+      def after_feature_element(feature_element)
         @io.puts
         @io.flush
       end
 
-      def visit_background(background)
+      def before_background(background)
         @indent = 2
         @scenario_indent = 2
         @in_background = true
-        super
+      end
+
+      def after_background(background)
         @in_background = nil
         @io.puts
         @io.flush
       end
 
-      def visit_background_name(keyword, name, file_colon_line, source_indent)
-        visit_feature_element_name(keyword, name, file_colon_line, source_indent)
+      def background_name(keyword, name, file_colon_line, source_indent)        
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
       end
 
-      def visit_examples_array(examples_array)
+      def before_examples_array(examples_array)
         @indent = 4
         @io.puts
-        examples_array[0..-2].each { |ea| super(ea) }
-        @last_example = true
-        super(examples_array.last)
-        @last_example = nil
+        @visiting_first_example_name = true
       end
       
-      def visit_examples_name(keyword, name)
-        names = name.strip.empty? ? [name.strip] : name.split("\n")        
+      def examples_name(keyword, name)
+        puts unless @visiting_first_example_name
+        @visiting_first_example_name = false
+        names = name.strip.empty? ? [name.strip] : name.split("\n")
         @io.puts("    #{keyword} #{names[0]}")
         names[1..-1].each {|s| @io.puts "      #{s}" } unless names.empty?
         @io.flush
         @indent = 6
         @scenario_indent = 6
       end
+      
+      def before_outline_table(outline_table)
+        @table = outline_table
+      end
 
-      def visit_outline_table(outline_table)
-        super
+      def after_outline_table(outline_table)
+        @table = nil
         @indent = 4
-        @io.puts unless @last_example
       end
       
-      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
-        visit_feature_element_name(keyword, name, file_colon_line, source_indent)
-      end
-
-      def visit_feature_element_name(keyword, name, file_colon_line, source_indent)
-        @io.puts if @scenario_indent == 6
-        names = name.empty? ? [name] : name.split("\n")
-        line = "#{keyword} #{names[0]}".indent(@scenario_indent)
-        @io.print(line)
-        if @options[:source]
-          line_comment = " # #{file_colon_line}".indent(source_indent)
-          @io.print(format_string(line_comment, :comment))
-        end
-        @io.puts
-        names[1..-1].each {|s| @io.puts "    #{s}"}
-        @io.flush
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        print_feature_element_name keyword, name, file_colon_line, source_indent
       end
 
-      def visit_step(step)
+      def before_step(step)
+        @current_step = step
         @indent = 6
-        super
       end
 
-      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        @hide_this_step = false
         if exception
-          return if @exceptions.index(exception)
+          if @exceptions.include?(exception)
+            @hide_this_step = true
+            return
+          end
           @exceptions << exception
         end
-        return if status != :failed && @in_background ^ background
+        if status != :failed && @in_background ^ background
+          @hide_this_step = true
+          return
+        end
         @status = status
-        super
       end
 
-      def visit_step_name(keyword, step_match, status, source_indent, background)
+      def step_name(keyword, step_match, status, source_indent, background)
+        return if @hide_this_step
         source_indent = nil unless @options[:source]
         formatted_step_name = format_step(keyword, step_match, status, source_indent)
         @io.puts(formatted_step_name.indent(@scenario_indent + 2))
       end
 
-      def visit_multiline_arg(multiline_arg)
-        return if @options[:no_multiline]
-        @table = multiline_arg
-        super
+      def py_string(string)
+        return if @hide_this_step
+        s = %{"""\n#{string}\n"""}.indent(@indent)
+        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
+        @io.puts(format_string(s, @current_step.status))
+        @io.flush
       end
 
-      def visit_exception(exception, status)
+      def exception(exception, status)
+        return if @hide_this_step
         print_exception(exception, status, @indent)
         @io.flush
       end
 
-      def visit_table_row(table_row)
+      def before_multiline_arg(multiline_arg)
+        return if @options[:no_multiline] || @hide_this_step
+        @table = multiline_arg
+      end
+      
+      def after_multiline_arg(multiline_arg)
+        @table = nil
+      end
+
+      def before_table_row(table_row)
+        return unless @table
         @col_index = 0
         @io.print '  |'.indent(@indent-2)
-        super
+      end
+
+      def after_table_row(table_row)
+        return unless @table
         @io.puts
-        if table_row.exception && !@exceptions.index(table_row.exception)
+        if table_row.exception && !@exceptions.include?(table_row.exception)
           print_exception(table_row.exception, :failed, @indent)
         end
       end
 
-      def visit_py_string(string)
-        s = %{"""\n#{string}\n"""}.indent(@indent)
-        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
-        @io.puts(format_string(s, @status))
-        @io.flush
-      end
-
-      def visit_table_cell(cell)
-        super
+      def after_table_cell(cell)
+        return unless @table
         @col_index += 1
       end
 
-      def visit_table_cell_value(value, status)
+      def table_cell_value(value, status)
+        return unless @table
         status ||= @status || :passed
         width = @table.col_width(@col_index)
         cell_text = value.to_s || ''
@@ -205,6 +206,20 @@ module Cucumber
       end
 
       private
+      
+      def print_feature_element_name(keyword, name, file_colon_line, source_indent)
+        @io.puts if @scenario_indent == 6
+        names = name.empty? ? [name] : name.split("\n")
+        line = "#{keyword} #{names[0]}".indent(@scenario_indent)
+        @io.print(line)
+        if @options[:source]
+          line_comment = " # #{file_colon_line}".indent(source_indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+        names[1..-1].each {|s| @io.puts "    #{s}"}
+        @io.flush        
+      end
 
       def cell_prefix(status)
         @prefixes[status]