cucumber 0.3.102 → 0.3.103

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/core_ext/string.rb

@@ -7,28 +7,6 @@ class String #:nodoc:
     end
   end
   
-  # TODO: Move to StepMatch
-  # +groups+ is an array of 2-element arrays, where
-  # the 1st element is the value of a regexp match group,
-  # and the 2nd element is its start index.
-  def gzub(groups, format=nil, &proc)
-    s = dup
-    offset = 0
-    groups.each do |group|
-      replacement = if block_given?
-        proc.call(group.val)
-      elsif Proc === format
-        format.call(group.val)
-      else
-        format % group.val
-      end
-      
-      s[group.start + offset, group.val.length] = replacement
-      offset += replacement.length - group.val.length
-    end
-    s
-  end
-
   if (Cucumber::JRUBY && Cucumber::RAILS) || Cucumber::RUBY_1_9
     # Workaround for http://tinyurl.com/55uu3u 
     alias jlength length

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