aslakhellesoy-cucumber 0.3.102.2 → 0.3.103

data/History.txt

@@ -1,4 +1,4 @@
-== (In Git)
+== 2009-09-24
 
 This release gives you back some of the control over the Rails environment that was accidentally taken away from you in the 
 previous release.
@@ -6,13 +6,16 @@ previous release.
 Using this release on a Rails project requires a rerun of script/generate cucumber.
 
 === New Features
-* Added a new @no-txn tag to selectively turn off transactions for a particluar scenario.
+* Added a new @no-txn tag to selectively turn off transactions for a particlular scenario.
 * Added back a way to globally turn off transactions.
 * Renamed @allow_rescue tag to @allow-rescue.
 
 === Bugfixes
 * Gracefully handle cases when optional regexp groups are not matched. Ex: /should( not)? be flashed '([^']*?)'$/ (Aslak Hellesøy)
 
+=== Changed Features
+* The Formatter API has completely changed. Formatters are no longer a double-dispacth visitor - just a single-dispatch listener (#438 Matt Wynne)
+
 == 2009-09-22
 
 This release has some changes in the Rails support, so make sure you run "script/generate cucumber" after you upgrade.

data/Manifest.txt

@@ -329,6 +329,7 @@ lib/cucumber/ast/step_collection.rb
 lib/cucumber/ast/step_invocation.rb
 lib/cucumber/ast/table.rb
 lib/cucumber/ast/tags.rb
+lib/cucumber/ast/tree_walker.rb
 lib/cucumber/ast/visitor.rb
 lib/cucumber/broadcaster.rb
 lib/cucumber/cli/configuration.rb
@@ -421,6 +422,7 @@ spec/cucumber/ast/scenario_spec.rb
 spec/cucumber/ast/step_collection_spec.rb
 spec/cucumber/ast/step_spec.rb
 spec/cucumber/ast/table_spec.rb
+spec/cucumber/ast/tree_walker_spec.rb
 spec/cucumber/broadcaster_spec.rb
 spec/cucumber/cli/configuration_spec.rb
 spec/cucumber/cli/drb_client_spec.rb

data/examples/self_test/features/sample.feature

@@ -12,7 +12,7 @@ Feature: Sample
     Given passing
       |a|b|
       |c|d|
-  
+
   @four
   Scenario: Failing
     Given failing

data/examples/self_test/features/search_sample.feature

@@ -20,7 +20,7 @@ Feature: search examples
     Examples:
       | state   |
       | passing |
-  
+
   Scenario Outline: no match in name but in examples
     Given <state> without a table
     Examples: Hantu Pisang

data/features/custom_formatter.feature

@@ -8,7 +8,7 @@ Feature: Custom Formatter
       | 1           | 1                                    | 1     | 1     | 1    | 2            | 1           | 2             | 1           | 2      | 1    |
 
       """
-  
+
     Scenario: my own formatter
       Given a standard Cucumber project directory structure
       And a file named "features/f.feature" with:
@@ -25,13 +25,13 @@ Feature: Custom Formatter
       And a file named "features/support/ze/formator.rb" with:
         """
         module Ze
-          class Formator < Cucumber::Ast::Visitor
+          class Formator
             def initialize(step_mother, io, options)
-              super(step_mother)
+              @step_mother = step_mother
               @io = io
             end
 
-            def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+            def scenario_name(keyword, name, file_colon_line, source_indent)
               @io.puts "$ #{name.upcase}"
             end
           end

data/lib/cucumber/ast.rb

@@ -13,6 +13,7 @@ require 'cucumber/ast/py_string'
 require 'cucumber/ast/outline_table'
 require 'cucumber/ast/examples'
 require 'cucumber/ast/visitor'
+require 'cucumber/ast/tree_walker'
 
 module Cucumber
   # Classes in this module represent the Abstract Syntax Tree (AST)

data/lib/cucumber/ast/table.rb

@@ -389,11 +389,11 @@ module Cucumber
 
         c = Term::ANSIColor.coloring?
         Term::ANSIColor.coloring = options[:color]
-        f = Formatter::Pretty.new(nil, io, options)
-        f.instance_variable_set('@indent', options[:indent])
-        f.visit_multiline_arg(self)
+        formatter = Formatter::Pretty.new(nil, io, options)
+        formatter.instance_variable_set('@indent', options[:indent])
+        TreeWalker.new(nil, [formatter]).visit_multiline_arg(self)
+        
         Term::ANSIColor.coloring = c
-
         io.rewind
         s = "\n" + io.read + (" " * (options[:indent] - 2))
         s

data/lib/cucumber/ast/visitor.rb

@@ -1,115 +1,11 @@
 module Cucumber
   module Ast
-    # Base class for formatters. This class just walks the tree depth first.
-    # Just override the methods you care about. Remember to call super if you
-    # override a method.
     class Visitor
-      attr_accessor :options #:nodoc:
-      attr_reader :step_mother #:nodoc:
+      DEPRECATION_WARNING = "Cucumber::Ast::Visitor is deprecated and will be removed. You no longer need to inherit from this class."
 
       def initialize(step_mother)
-        @options = {}
-        @step_mother = step_mother
+        raise(DEPRECATION_WARNING)
       end
-
-      def visit_features(features)
-        features.accept(self)
-      end
-
-      def visit_feature(feature)
-        feature.accept(self)
-      end
-
-      def visit_comment(comment)
-        comment.accept(self)
-      end
-
-      def visit_comment_line(comment_line)
-      end
-
-      def visit_tags(tags)
-        tags.accept(self)
-      end
-
-      def visit_tag_name(tag_name)
-      end
-
-      def visit_feature_name(name)
-      end
-
-      # +feature_element+ is either Scenario or ScenarioOutline
-      def visit_feature_element(feature_element)
-        feature_element.accept(self)
-      end
-
-      def visit_background(background)
-        background.accept(self)
-      end
-
-      def visit_background_name(keyword, name, file_colon_line, source_indent)
-      end
-
-      def visit_examples_array(examples_array)
-        examples_array.accept(self)
-      end
-
-      def visit_examples(examples)
-        examples.accept(self)
-      end
-
-      def visit_examples_name(keyword, name)
-      end
-
-      def visit_outline_table(outline_table)
-        @table = outline_table
-        outline_table.accept(self)
-      end
-
-      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
-      end
-
-      def visit_steps(steps)
-        steps.accept(self)
-      end
-
-      def visit_step(step)
-        step.accept(self)
-      end
-
-      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
-        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
-
-      def visit_step_name(keyword, step_match, status, source_indent, background) #:nodoc:
-      end
-
-      def visit_multiline_arg(multiline_arg) #:nodoc:
-        multiline_arg.accept(self)
-      end
-
-      def visit_exception(exception, status) #:nodoc:
-      end
-
-      def visit_py_string(string)
-      end
-
-      def visit_table_row(table_row)
-        table_row.accept(self)
-      end
-
-      def visit_table_cell(table_cell)
-        table_cell.accept(self)
-      end
-
-      def visit_table_cell_value(value, status)
-      end
-
-      # Print +announcement+. This method can be called from within StepDefinitions.
-      def announce(announcement)
-      end
-
     end
   end
 end

data/lib/cucumber/cli/configuration.rb

@@ -57,34 +57,9 @@ module Cucumber
       def drb_port
         @options[:drb_port].to_i if @options[:drb_port]
       end
-
-      def build_formatter_broadcaster(step_mother)
-        return Formatter::Pretty.new(step_mother, nil, @options) if @options[:autoformat]
-        formatters = @options[:formats].map do |format_and_out|
-          format = format_and_out[0]
-          out    = format_and_out[1]
-          if String === out # file name
-            unless File.directory?(out)
-              out = File.open(out, Cucumber.file_mode('w'))
-              at_exit do
-                out.flush
-                out.close
-              end
-            end
-          end
-
-          begin
-            formatter_class = formatter_class(format)
-            formatter_class.new(step_mother, out, @options)
-          rescue Exception => e
-            e.message << "\nError creating formatter: #{format}"
-            raise e
-          end
-        end
-
-        broadcaster = Broadcaster.new(formatters)
-        broadcaster.options = @options
-        return broadcaster
+      
+      def build_runner(step_mother, io)
+        Ast::TreeWalker.new(step_mother, formatters(step_mother), @options, io)
       end
 
       def formatter_class(format)
@@ -150,6 +125,31 @@ module Cucumber
       end
 
     private
+    
+      def formatters(step_mother)
+        return [Formatter::Pretty.new(step_mother, nil, @options)] if @options[:autoformat]
+        @options[:formats].map do |format_and_out|
+          format = format_and_out[0]
+          out    = format_and_out[1]
+          if String === out # file name
+            unless File.directory?(out)
+              out = File.open(out, Cucumber.file_mode('w'))
+              at_exit do
+                out.flush
+                out.close
+              end
+            end
+          end
+
+          begin
+            formatter_class = formatter_class(format)
+            formatter_class.new(step_mother, out, @options)
+          rescue Exception => e
+            e.message << "\nError creating formatter: #{format}"
+            raise e
+          end
+        end
+      end
 
       class LogFormatter < ::Logger::Formatter
         def call(severity, time, progname, msg)

data/lib/cucumber/cli/language_help_formatter.rb

@@ -19,7 +19,8 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
           [lang, Cucumber::LANGUAGES[lang]['name'], Cucumber::LANGUAGES[lang]['native']]
         end
         table = Ast::Table.new(raw)
-        new(nil, io, {:check_lang=>true}).visit_multiline_arg(table)
+        formatter = new(nil, io, {:check_lang=>true})
+        Ast::TreeWalker.new(nil, [formatter]).visit_multiline_arg(table)
       end
 
       def self.list_keywords(io, lang)
@@ -31,19 +32,17 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
         new(nil, io, {:incomplete => language.incomplete?}).visit_multiline_arg(table)
       end
 
-      def visit_multiline_arg(table)
+      def before_visit_multiline_arg(table)
         if @options[:incomplete]
           @io.puts(format_string(INCOMPLETE, :failed))
         end
-        super
       end
 
-      def visit_table_row(table_row)
+      def before_visit_table_row(table_row)
         @col = 1
-        super
       end
 
-      def visit_table_cell_value(value, status)
+      def before_visit_table_cell_value(value, status)
         if @col == 1
           if(@options[:check_lang])
             @incomplete = Parser::NaturalLanguage.get(nil, value).incomplete?
@@ -54,7 +53,6 @@ http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
         end
         
         @col += 1
-        super(value, status)
       end
     end
   end

data/lib/cucumber/cli/main.rb

@@ -50,9 +50,9 @@ module Cucumber
 
         enable_diffing
 
-        visitor = configuration.build_formatter_broadcaster(step_mother)
-        step_mother.visitor = visitor # Needed to support World#announce
-        visitor.visit_features(features)
+        runner = configuration.build_runner(step_mother, @out_stream)
+        step_mother.visitor = runner # Needed to support World#announce
+        runner.visit_features(features)
 
         failure = if exceeded_tag_limts?(features)
             FAILURE

data/lib/cucumber/formatter/html.rb

@@ -1,214 +1,278 @@
 require 'cucumber/formatter/ordered_xml_markup'
 require 'cucumber/formatter/duration'
+require 'xml'
+require 'ruby-debug'
 
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format html</tt>
-    class Html < Ast::Visitor
+    class Html
       include ERB::Util # for the #h method
       include Duration
 
       def initialize(step_mother, io, options)
-        super(step_mother)
+        @io = io
         @options = options
-        @builder = create_builder(io)
+        @buffer = {}
+        @current_builder = create_builder(@io)
       end
       
-      def create_builder(io)
-        OrderedXmlMarkup.new(:target => io, :indent => 0)
+      def before_features(features)
+        start_buffering :features
       end
       
-      def visit_features(features)
+      def after_features(features)
+        stop_buffering :features
         # <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-        @builder.declare!(
+        builder.declare!(
           :DOCTYPE,
           :html, 
           :PUBLIC, 
           '-//W3C//DTD XHTML 1.0 Strict//EN', 
           'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'
         )
-        @builder.html(:xmlns => 'http://www.w3.org/1999/xhtml') do
-          @builder.head do
-            @builder.meta(:content => 'text/html;charset=utf-8')
-            @builder.title 'Cucumber'
+        builder.html(:xmlns => 'http://www.w3.org/1999/xhtml') do
+          builder.head do
+            builder.meta(:content => 'text/html;charset=utf-8')
+            builder.title 'Cucumber'
             inline_css
           end
-          @builder.body do
-            @builder.div(:class => 'cucumber') do
-              super
-              @builder.div(format_duration(features.duration), :class => 'duration')
+          builder.body do
+            builder.div(:class => 'cucumber') do
+              builder << buffer(:features)
+              builder.div(format_duration(features.duration), :class => 'duration')
             end
           end
         end
       end
-
-      def visit_comment(comment)
-        @builder.pre(:class => 'comment') do
-          super
+      
+      def before_feature(feature)
+        start_buffering :feature
+        @exceptions = []
+      end
+      
+      def after_feature(feature)
+        stop_buffering :feature
+        builder.div(:class => 'feature') do
+          builder << buffer(:feature)
         end
       end
 
-      def visit_comment_line(comment_line)
-        @builder.text!(comment_line)
-        @builder.br
+      def before_comment(comment)
+        start_buffering :comment
       end
 
-      def visit_feature(feature)
-        @exceptions = []
-        @builder.div(:class => 'feature') do
-          super
+      def after_comment(comment)
+        stop_buffering :comment
+        builder.pre(:class => 'comment') do
+          builder << buffer(:comment)
         end
       end
 
-      def visit_tags(tags)
-        super
+      def comment_line(comment_line)
+        builder.text!(comment_line)
+        builder.br
+      end
+      
+      def after_tags(tags)
         @tag_spacer = nil
       end
-
-      def visit_tag_name(tag_name)
-        @builder.text!(@tag_spacer) if @tag_spacer
+      
+      def tag_name(tag_name)
+        builder.text!(@tag_spacer) if @tag_spacer
         @tag_spacer = ' '
-        @builder.span(tag_name, :class => 'tag')
+        builder.span(tag_name, :class => 'tag')
       end
 
-      def visit_feature_name(name)
+      def feature_name(name)
         lines = name.split(/\r?\n/)
         return if lines.empty?
-        @builder.h2 do |h2|
-          @builder.span(lines[0], :class => 'val')
+        builder.h2 do |h2|
+          builder.span(lines[0], :class => 'val')
         end
-        @builder.p(:class => 'narrative') do
+        builder.p(:class => 'narrative') do
           lines[1..-1].each do |line|
-            @builder.text!(line.strip)
-            @builder.br
+            builder.text!(line.strip)
+            builder.br
           end
         end
       end
 
-      def visit_background(background)
-        @builder.div(:class => 'background') do
-          @in_background = true
-          super
-          @in_background = nil
+      def before_background(background)
+        @in_background = true
+        start_buffering :background
+      end
+      
+      def after_background(background)
+        stop_buffering :background
+        @in_background = nil
+        builder.div(:class => 'background') do
+          builder << buffer(:background)
         end
       end
 
-      def visit_background_name(keyword, name, file_colon_line, source_indent)
+      def background_name(keyword, name, file_colon_line, source_indent)
         @listing_background = true
-        @builder.h3 do |h3|
-          @builder.span(keyword, :class => 'keyword')
-          @builder.text!(' ')
-          @builder.span(name, :class => 'val')
+        builder.h3 do |h3|
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(name, :class => 'val')
         end
       end
 
-      def visit_feature_element(feature_element)
+      def before_feature_element(feature_element)
+        start_buffering :feature_element
+      end
+      
+      def after_feature_element(feature_element)
+        stop_buffering :feature_element
         css_class = {
           Ast::Scenario        => 'scenario',
           Ast::ScenarioOutline => 'scenario outline'
         }[feature_element.class]
-        @builder.div(:class => css_class) do
-          super
+
+        builder.div(:class => css_class) do
+          builder << buffer(:feature_element)
         end
         @open_step_list = true
       end
-      
-      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
         @listing_background = false
-        @builder.h3 do
-          @builder.span(keyword, :class => 'keyword')
-          @builder.text!(' ')
-          @builder.span(name, :class => 'val')
+        builder.h3 do
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(name, :class => 'val')
         end
       end
-
-      def visit_outline_table(outline_table)
+      
+      def before_outline_table(outline_table)
         @outline_row = 0
-        @builder.table do
-          super(outline_table)
+        start_buffering :outline_table
+      end
+      
+      def after_outline_table(outline_table)
+        stop_buffering :outline_table
+        builder.table do
+          builder << buffer(:outline_table)
         end
         @outline_row = nil
       end
 
-      def visit_examples(examples)
-        @builder.div(:class => 'examples') do
-          super(examples)
+      def before_examples(examples)
+        start_buffering :examples
+      end
+      
+      def after_examples(examples)
+        stop_buffering :examples
+        builder.div(:class => 'examples') do
+          builder << buffer(:examples)
         end
       end
 
-      def visit_examples_name(keyword, name)
-        @builder.h4 do
-          @builder.span(keyword, :class => 'keyword')
-          @builder.text!(' ')
-          @builder.span(name, :class => 'val')
+      def examples_name(keyword, name)
+        builder.h4 do
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(name, :class => 'val')
         end
       end
 
-      def visit_steps(steps)
-        @builder.ol do
-          super
+      def before_steps(steps)
+        start_buffering :steps
+      end
+      
+      def after_steps(steps)
+        stop_buffering :steps
+        builder.ol do
+          builder << buffer(:steps)
         end
       end
-
-      def visit_step(step)
+      
+      def before_step(step)
         @step_id = step.dom_id
-        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)
+        start_buffering :step_result
+        @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
-        @builder.li(:id => @step_id, :class => "step #{status}") do
-          super(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+      end
+      
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        stop_buffering :step_result
+        return if @hide_this_step
+        builder.li(:id => @step_id, :class => "step #{status}") do
+          builder << buffer(:step_result)
         end
       end
 
-      def visit_step_name(keyword, step_match, status, source_indent, background)
+      def step_name(keyword, step_match, status, source_indent, background)
         @step_matches ||= []
         background_in_scenario = background && !@listing_background
         @skip_step = @step_matches.index(step_match) || background_in_scenario
         @step_matches << step_match
-
+      
         unless @skip_step
           build_step(keyword, step_match, status)
         end
       end
 
-      def visit_exception(exception, status)
-        @builder.pre(format_exception(exception), :class => status)
+      def exception(exception, status)
+        return if @hide_this_step
+        builder.pre(format_exception(exception), :class => status)
+      end
+      
+      def before_multiline_arg(multiline_arg)
+        start_buffering :multiline_arg
       end
 
-      def visit_multiline_arg(multiline_arg)
-        return if @skip_step
+      def after_multiline_arg(multiline_arg)
+        stop_buffering :multiline_arg
+        return if @hide_this_step || @skip_step
         if Ast::Table === multiline_arg
-          @builder.table do
-            super
+          builder.table do
+            builder << buffer(:multiline_arg)
           end
         else
-          super
+          builder << buffer(:multiline_arg)
         end
       end
 
-      def visit_py_string(string)
-        @builder.pre(:class => 'val') do |pre|
-          @builder << string.gsub("\n", '&#x000A;')
+      def py_string(string)
+        return if @hide_this_step
+        builder.pre(:class => 'val') do |pre|
+          builder << string.gsub("\n", '&#x000A;')
         end
       end
 
-      def visit_table_row(table_row)
+      def before_table_row(table_row)
         @row_id = table_row.dom_id
         @col_index = 0
-        @builder.tr(:id => @row_id) do
-          super
+        start_buffering :table_row
+      end
+      
+      def after_table_row(table_row)
+        stop_buffering :table_row
+        return if @hide_this_step
+        builder.tr(:id => @row_id) do
+          builder << buffer(:table_row)
         end
         if table_row.exception
-          @builder.tr do
-            @builder.td(:colspan => @col_index.to_s, :class => 'failed') do
-              @builder.pre do |pre|
+          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
@@ -217,45 +281,71 @@ module Cucumber
         @outline_row += 1 if @outline_row
       end
 
-      def visit_table_cell_value(value, status)
+      def table_cell_value(value, status)
+        return if @hide_this_step
+        
         cell_type = @outline_row == 0 ? :th : :td
         attributes = {:id => "#{@row_id}_#{@col_index}", :class => 'val'}
         attributes[:class] += " #{status}" if status
         build_cell(cell_type, value, attributes)
         @col_index += 1
       end
-      
+
       def announce(announcement)
-        @builder.pre(announcement, :class => 'announcement')
+        builder.pre(announcement, :class => 'announcement')
       end
-
-      protected
+      
+      private
       
       def build_step(keyword, step_match, status)
         step_name = step_match.format_args(lambda{|param| %{<span class="param">#{param}</span>}})
-        @builder.div do |div|
-          @builder.span(keyword, :class => 'keyword')
-          @builder.text!(' ')
-          @builder.span(:class => 'step val') do |name|
+        builder.div do |div|
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(:class => 'step val') do |name|
             name << h(step_name).gsub(/&lt;span class=&quot;(.*?)&quot;&gt;/, '<span class="\1">').gsub(/&lt;\/span&gt;/, '</span>')
           end
         end
       end
-      
+
       def build_cell(cell_type, value, attributes)
-        @builder.__send__(cell_type, value, attributes)
+        builder.__send__(cell_type, value, attributes)
       end
-
+      
       def inline_css
-        @builder.style(:type => 'text/css') do
-          @builder.text!(File.read(File.dirname(__FILE__) + '/cucumber.css'))
+        builder.style(:type => 'text/css') do
+          builder.text!(File.read(File.dirname(__FILE__) + '/cucumber.css'))
         end
       end
-
+      
       def format_exception(exception)
         h((["#{exception.message} (#{exception.class})"] + exception.backtrace).join("\n"))
       end
       
+      def builder
+        @current_builder
+      end
+      
+      def buffer(label)
+        result = @buffer[label]
+        @buffer[label] = ''
+        result
+      end
+      
+      def start_buffering(label)
+        @buffer[label] ||= ''
+        @parent_builder ||= {}
+        @parent_builder[label] = @current_builder
+        @current_builder = create_builder(@buffer[label])
+      end
+      
+      def stop_buffering(label)
+        @current_builder = @parent_builder[label]
+      end
+      
+      def create_builder(io)
+        OrderedXmlMarkup.new(:target => io, :indent => 0)
+      end      
     end
   end
 end