cucumber 3.0.0.pre.2 → 4.0.0.rc.5

data/lib/cucumber/formatter/backtrace_filter.rb

@@ -1,25 +1,26 @@
 # frozen_string_literal: true
-require 'cucumber/platform'
 
+require 'cucumber/platform'
 
 module Cucumber
   module Formatter
-    @backtrace_filters = %w(
+    @backtrace_filters = %w[
       /vendor/rails
       lib/cucumber
       bin/cucumber:
       lib/rspec
       gems/
+      site_ruby/
       minitest
       test/unit
       .gem/ruby
-      lib/ruby/
       bin/bundle
-    )
+    ]
 
-    if ::Cucumber::JRUBY
-      @backtrace_filters << 'org/jruby/'
-    end
+    @backtrace_filters << RbConfig::CONFIG['rubyarchdir'] if RbConfig::CONFIG['rubyarchdir']
+    @backtrace_filters << RbConfig::CONFIG['rubylibdir'] if RbConfig::CONFIG['rubylibdir']
+
+    @backtrace_filters << 'org/jruby/' if ::Cucumber::JRUBY
 
     BACKTRACE_FILTER_PATTERNS = Regexp.new(@backtrace_filters.join('|'))
 
@@ -31,7 +32,7 @@ module Cucumber
       def exception
         return @exception if ::Cucumber.use_full_backtrace
 
-        pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m
+        pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m # rubocop:disable Style/RegexpLiteral
         backtrace = @exception.backtrace.map { |line| line.gsub(pwd_pattern, './') }
 
         filtered = (backtrace || []).reject do |line|
@@ -41,7 +42,7 @@ module Cucumber
         if ::ENV['CUCUMBER_TRUNCATE_OUTPUT']
           # Strip off file locations
           filtered = filtered.map do |line|
-            line =~ /(.*):in `/ ? $1 : line
+            line =~ /(.*):in `/ ? Regexp.last_match(1) : line
           end
         end
 
@@ -49,6 +50,5 @@ module Cucumber
         @exception
       end
     end
-
   end
 end

data/lib/cucumber/formatter/console.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/formatter/duration'
 require 'cucumber/gherkin/i18n'
 
 module Cucumber
   module Formatter
-
     # This module contains helper methods that are used by formatters that
     # print output to the terminal.
     #
@@ -46,7 +46,7 @@ module Cucumber
       def format_string(o, status)
         fmt = format_for(status)
         o.to_s.split("\n").map do |line|
-          if Proc === fmt
+          if Proc == fmt.class
             fmt.call(line)
           else
             fmt % line
@@ -54,10 +54,6 @@ module Cucumber
         end.join("\n")
       end
 
-      def print_steps(status)
-        print_elements(runtime.steps(status), status, 'steps')
-      end
-
       def print_elements(elements, status, kind)
         return if elements.empty?
 
@@ -109,33 +105,30 @@ module Cucumber
       end
 
       # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/10655
-      def linebreaks(s, max)
-        return s unless max && max > 0
-        s.gsub(/.{1,#{max}}(?:\s|\Z)/){($& + 5.chr).gsub(/\n\005/,"\n").gsub(/\005/,"\n")}.rstrip
+      def linebreaks(msg, max)
+        return msg unless max && max > 0
+        msg.gsub(/.{1,#{max}}(?:\s|\Z)/) { ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n") }.rstrip
       end
 
-      def collect_snippet_data(test_step, result)
+      def collect_snippet_data(test_step, ast_lookup)
         # collect snippet data for undefined steps
-        return if hook?(test_step)
-        keyword = test_step.source.last.actual_keyword(@previous_step_keyword)
-        @previous_step_keyword = keyword
-        return unless result.undefined?
-        @snippets_input << Console::SnippetData.new(keyword, test_step.source.last)
+        keyword = ast_lookup.snippet_step_keyword(test_step)
+        @snippets_input << Console::SnippetData.new(keyword, test_step)
       end
 
       def print_snippets(options)
         return unless options[:snippets]
-        return if runtime.steps(:undefined).empty?
+        return if @snippets_input.empty?
 
-        snippet_text_proc = lambda { |step_keyword, step_name, multiline_arg|
-          runtime.snippet_text(step_keyword, step_name, multiline_arg)
-        }
+        snippet_text_proc = lambda do |step_keyword, step_name, multiline_arg|
+          snippet_text(step_keyword, step_name, multiline_arg)
+        end
         do_print_snippets(snippet_text_proc)
       end
 
       def do_print_snippets(snippet_text_proc)
         snippets = @snippets_input.map do |data|
-          snippet_text_proc.call(data.actual_keyword, data.step.name, data.step.multiline_arg)
+          snippet_text_proc.call(data.actual_keyword, data.step.text, data.step.multiline_arg)
         end.uniq
 
         text = "\nYou can implement step definitions for undefined steps with these snippets:\n\n"
@@ -146,10 +139,14 @@ module Cucumber
         @io.flush
       end
 
-      def print_passing_wip(options)
-        return unless options[:wip]
-        passed_messages = element_messages(runtime.scenarios(:passed), :passed)
-        do_print_passing_wip(passed_messages)
+      def print_passing_wip(config, passed_test_cases, ast_lookup)
+        return unless config.wip?
+        messages = passed_test_cases.map do |test_case|
+          scenario_source = ast_lookup.scenario_source(test_case)
+          keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
+          linebreaks("#{test_case.location.on_line(test_case.location.lines.max)}:in `#{keyword}: #{test_case.name}'", ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
+        end
+        do_print_passing_wip(messages)
       end
 
       def do_print_passing_wip(passed_messages)
@@ -161,62 +158,32 @@ module Cucumber
         end
       end
 
-      def embed(file, mime_type, label)
-        # no-op
-      end
-
-      #define @delayed_messages = [] in your Formatter if you want to
-      #activate this feature
-      def puts(*messages)
-        if @delayed_messages
-          @delayed_messages += messages
-        else
-          if @io
-            @io.puts
-            messages.each do |message|
-              @io.puts(format_string(message, :tag))
-            end
-            @io.flush
-          end
-        end
-      end
-
-      def print_messages
-        @delayed_messages.each {|message| print_message(message)}
-        empty_messages
-      end
-
-      def print_table_row_messages
-        return if @delayed_messages.empty?
-        @io.print(format_string(@delayed_messages.join(', '), :tag).indent(2))
-        @io.flush
-        empty_messages
-      end
-
-      def print_message(message)
-        @io.puts(format_string(message, :tag).indent(@indent))
+      def attach(src, media_type)
+        return unless media_type == 'text/x.cucumber.log+plain'
+        return unless @io
+        @io.puts
+        @io.puts(format_string(src, :tag))
         @io.flush
       end
 
-      def empty_messages
-        @delayed_messages = []
-      end
-
       def print_profile_information
         return if @options[:skip_profile_information] || @options[:profiles].nil? || @options[:profiles].empty?
         do_print_profile_information(@options[:profiles])
       end
 
       def do_print_profile_information(profiles)
-        profiles_sentence = profiles.size == 1 ? profiles.first :
-          "#{profiles[0...-1].join(', ')} and #{profiles.last}"
+        profiles_sentence = if profiles.size == 1
+                              profiles.first
+                            else
+                              "#{profiles[0...-1].join(', ')} and #{profiles.last}"
+                            end
 
-        @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size> 1}..."
+        @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size > 1}..."
       end
 
       private
 
-      FORMATS = Hash.new{ |hash, format| hash[format] = method(format).to_proc }
+      FORMATS = Hash.new { |hash, format| hash[format] = method(format).to_proc }
 
       def format_for(*keys)
         key = keys.join('_').to_sym
@@ -225,10 +192,6 @@ module Cucumber
         fmt
       end
 
-      def hook?(test_step)
-        not test_step.source.last.respond_to?(:actual_keyword)
-      end
-
       def element_messages(elements, status)
         elements.map do |element|
           if status == :failed
@@ -241,18 +204,18 @@ module Cucumber
 
       def snippet_text(step_keyword, step_name, multiline_arg)
         keyword = Cucumber::Gherkin::I18n.code_keyword_for(step_keyword).strip
-        config.snippet_generators.map { |generator|
+        config.snippet_generators.map do |generator|
           generator.call(keyword, step_name, multiline_arg, config.snippet_type)
-        }.join("\n")
+        end.join("\n")
       end
 
       class SnippetData
         attr_reader :actual_keyword, :step
         def initialize(actual_keyword, step)
-          @actual_keyword, @step = actual_keyword, step
+          @actual_keyword = actual_keyword
+          @step = step
         end
       end
-
     end
   end
 end

data/lib/cucumber/formatter/console_counts.rb

@@ -29,15 +29,10 @@ module Cucumber
       end
 
       def status_counts(summary)
-        counts = Core::Test::Result::TYPES.map { |status|
-          count = summary.total(status)
-          [status, count]
-        }.select { |status, count|
-          count > 0
-        }.map { |status, count|
-          format_string("#{count} #{status}", status)
-        }
-        "(#{counts.join(", ")})" if counts.any?
+        counts = Core::Test::Result::TYPES.map { |status| [status, summary.total(status)] }
+        counts = counts.select { |_status, count| count > 0 }
+        counts = counts.map { |status, count| format_string("#{count} #{status}", status) }
+        "(#{counts.join(', ')})" if counts.any?
       end
     end
   end

data/lib/cucumber/formatter/console_issues.rb

@@ -5,19 +5,20 @@ module Cucumber
     class ConsoleIssues
       include Console
 
-      def initialize(config)
+      def initialize(config, ast_lookup = AstLookup.new(config))
         @previous_test_case = nil
         @issues = Hash.new { |h, k| h[k] = [] }
         @config = config
         @config.on_event(:test_case_finished) do |event|
           if event.test_case != @previous_test_case
             @previous_test_case = event.test_case
-            @issues[event.result.to_sym] << event.test_case unless event.result.ok?(@config.strict?)
+            @issues[event.result.to_sym] << event.test_case unless event.result.ok?(@config.strict)
           elsif event.result.passed?
-            @issues[:flaky] << event.test_case unless Core::Test::Result::Flaky.ok?(@config.strict?)
+            @issues[:flaky] << event.test_case unless Core::Test::Result::Flaky.ok?(@config.strict.strict?(:flaky))
             @issues[:failed].delete(event.test_case)
           end
         end
+        @ast_lookup = ast_lookup
       end
 
       def to_s
@@ -34,10 +35,12 @@ module Cucumber
 
       def scenario_listing(type, test_cases)
         return [] if test_cases.empty?
-        [ format_string("#{type_heading(type)} Scenarios:", type) ] + test_cases.map { |test_case|
-          source = @config.source? ? format_string(" # #{test_case.keyword}: #{test_case.name}", :comment) : ''
-          format_string("cucumber #{profiles_string}" + test_case.location, type) + source
-        }
+        [format_string("#{type_heading(type)} Scenarios:", type)] + test_cases.map do |test_case|
+          scenario_source = @ast_lookup.scenario_source(test_case)
+          keyword = scenario_source.type == :Scenario ? scenario_source.scenario.keyword : scenario_source.scenario_outline.keyword
+          source = @config.source? ? format_string(" # #{keyword}: #{test_case.name}", :comment) : ''
+          format_string("cucumber #{profiles_string}#{test_case.location.file}:#{test_case.location.lines.max}", type) + source
+        end
       end
 
       def type_heading(type)

data/lib/cucumber/formatter/duration.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
     module Duration
@@ -7,7 +8,7 @@ module Cucumber
       # <tt>time</tt> format.
       def format_duration(seconds)
         m, s = seconds.divmod(60)
-        "#{m}m#{format('%.3f', s)}s"
+        "#{m}m#{format('%<seconds>.3f', seconds: s)}s"
       end
     end
   end

data/lib/cucumber/formatter/duration_extractor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
-
     class DurationExtractor
       attr_reader :result_duration
       def initialize(result)
@@ -22,8 +22,10 @@ module Cucumber
       def exception(*) end
 
       def duration(duration, *)
-        duration.tap { |duration| @result_duration = duration.nanoseconds / 10**9.0 }
+        duration.tap { |dur| @result_duration = dur.nanoseconds / 10**9.0 }
       end
+
+      def attach(*) end
     end
   end
 end

data/lib/cucumber/formatter/errors.rb

@@ -0,0 +1,6 @@
+module Cucumber
+  module Formatter
+    class TestCaseUnknownError < StandardError; end
+    class TestStepUnknownError < StandardError; end
+  end
+end

data/lib/cucumber/formatter/fail_fast.rb

@@ -1,20 +1,23 @@
 # frozen_string_literal: true
+
 require 'cucumber/formatter/io'
 require 'cucumber/formatter/console'
 
 module Cucumber
   module Formatter
-
     class FailFast
-
       def initialize(configuration)
+        @previous_test_case = nil
         configuration.on_event :test_case_finished do |event|
-          _test_case, result = *event.attributes
-          Cucumber.wants_to_quit = true unless result.ok?(configuration.strict?)
+          test_case, result = *event.attributes
+          if test_case != @previous_test_case
+            @previous_test_case = event.test_case
+            Cucumber.wants_to_quit = true unless result.ok?(configuration.strict)
+          elsif result.passed?
+            Cucumber.wants_to_quit = false
+          end
         end
       end
-
     end
-
   end
 end

data/lib/cucumber/formatter/fanout.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Cucumber
   module Formatter
-
     # Forwards any messages sent to this object to all recipients
     # that respond to that message.
     class Fanout < BasicObject
@@ -13,6 +13,8 @@ module Cucumber
       end
 
       def method_missing(message, *args)
+        super unless recipients
+
         recipients.each do |recipient|
           recipient.send(message, *args) if recipient.respond_to?(message)
         end
@@ -21,8 +23,6 @@ module Cucumber
       def respond_to_missing?(name, include_private = false)
         recipients.any? { |recipient| recipient.respond_to?(name, include_private) }
       end
-
     end
-
   end
 end

data/lib/cucumber/formatter/html.rb

@@ -1,615 +1,23 @@
-# frozen_string_literal: true
-require 'erb'
-require 'cucumber/formatter/duration'
 require 'cucumber/formatter/io'
-require 'cucumber/formatter/html_builder'
-require 'pathname'
+require 'cucumber/html_formatter'
+require 'cucumber/formatter/message_builder'
 
 module Cucumber
   module Formatter
-    class Html
-
-      # TODO: remove coupling to types
-      AST_CLASSES = {
-        Cucumber::Core::Ast::Scenario        => 'scenario',
-        Cucumber::Core::Ast::ScenarioOutline => 'scenario outline'
-      }
-
-      AST_DATA_TABLE = LegacyApi::Ast::MultilineArg::DataTable
-
-      include ERB::Util # for the #h method
-      include Duration
+    class HTML < MessageBuilder
       include Io
 
-      attr_reader :builder
-      private :builder
-
-      def initialize(runtime, path_or_io, options)
-        @io = ensure_io(path_or_io)
-        @runtime = runtime
-        @options = options
-        @buffer = {}
-        @builder = HtmlBuilder.new(target: @io, indent: 0)
-        @feature_number = 0
-        @scenario_number = 0
-        @step_number = 0
-        @header_red = nil
-        @delayed_messages = []
-        @inside_outline        = false
-        @previous_step_keyword = nil
-      end
-
-      def embed(src, mime_type, label)
-        if image?(mime_type)
-          src = src_is_file_or_data?(src) ? src : "data:#{standardize_mime_type(mime_type)},#{src}"
-
-          builder.embed_image(src: set_path(src), label: label, id: next_id(:img))
-        else
-          builder.embed_text(src: src, label: label, id: next_id(:text))
-        end
-      end
-
-      def set_path(src)
-        if @io.respond_to?(:path) and File.file?(src)
-          out_dir = Pathname.new(File.dirname(File.absolute_path(@io.path)))
-          src = Pathname.new(File.absolute_path(src)).relative_path_from(out_dir)
-        end
-
-        src
-      end
-
-      def standardize_mime_type(mime_type)
-        mime_type =~ /;base[0-9]+$/ ? mime_type : mime_type + ';base64'
-      end
-
-      def src_is_file_or_data?(src)
-        File.file?(src) or src =~ /^data:image\/(png|gif|jpg|jpeg);base64,/
-      end
-
-      def image?(mime_type)
-        mime_type =~ /^image\/(png|gif|jpg|jpeg)/
-      end
-
-      def before_features(features)
-        @step_count = features && features.step_count || 0 #TODO: Make this work with core!
-
-        builder.build_document!
-        builder.format_features! features
-      end
-
-      def after_features(features)
-        print_stats(features)
-        builder << '</div>'
-        builder << '</body>'
-        builder << '</html>'
-      end
-
-      def before_feature(_feature)
-        @exceptions = []
-        builder << '<div class="feature">'
-      end
-
-      def after_feature(_feature)
-        builder << '</div>'
-      end
-
-      def before_comment(_comment)
-        builder << '<pre class="comment">'
-      end
-
-      def after_comment(_comment)
-        builder << '</pre>'
-      end
-
-      def comment_line(comment_line)
-        builder.text!(comment_line)
-        builder.br
-      end
-
-      def after_tags(_tags)
-        @tag_spacer = nil
-      end
-
-      def tag_name(tag_name)
-        builder.text!(@tag_spacer) if @tag_spacer
-        @tag_spacer = ' '
-        builder.span(tag_name, :class => 'tag')
-      end
-
-      def feature_name(keyword, name)
-        lines = name.split(/\r?\n/)
-        return if lines.empty?
-        builder.h2 do |h2|
-          builder.span(keyword + ': ' + lines[0], :class => 'val')
-        end
-        builder.p(:class => 'narrative') do
-          lines[1..-1].each do |line|
-            builder.text!(line.strip)
-            builder.br
-          end
-        end
-      end
-
-      def before_test_case(_test_case)
-        @previous_step_keyword = nil
-      end
-
-      def before_background(_background)
-        @in_background = true
-        builder << '<div class="background">'
-      end
-
-      def after_background(_background)
-        @in_background = nil
-        builder << '</div>'
-      end
-
-      def background_name(keyword, name, _file_colon_line, _source_indent)
-        @listing_background = true
-        builder.h3(:id => "background_#{@scenario_number}") do |h3|
-          builder.span(keyword, :class => 'keyword')
-          builder.text!(' ')
-          builder.span(name, :class => 'val')
-        end
-      end
-
-      def before_feature_element(feature_element)
-        @scenario_number+=1
-        @scenario_red = false
-        css_class = AST_CLASSES[feature_element.class]
-        builder << "<div class='#{css_class}'>"
-        @in_scenario_outline = feature_element.class == Cucumber::Core::Ast::ScenarioOutline
-      end
-
-      def after_feature_element(_feature_element)
-        unless @in_scenario_outline
-          print_messages
-          builder << '</ol>'
-        end
-        builder << '</div>'
-        @in_scenario_outline = nil
-      end
-
-      def scenario_name(keyword, name, file_colon_line, _source_indent)
-        builder.span(:class => 'scenario_file') do
-          builder << file_colon_line
-        end
-        @listing_background = false
-        scenario_id = "scenario_#{@scenario_number}"
-        if @inside_outline
-          @outline_row += 1
-          scenario_id += "_#{@outline_row}"
-          @scenario_red = false
-        end
-        builder.h3(:id => scenario_id) do
-          builder.span(keyword + ':', :class => 'keyword')
-          builder.text!(' ')
-          builder.span(name, :class => 'val')
-        end
-      end
-
-      def before_outline_table(_outline_table)
-        @inside_outline = true
-        @outline_row = 0
-        builder << '<table>'
-      end
-
-      def after_outline_table(_outline_table)
-        builder << '</table>'
-        @outline_row = nil
-        @inside_outline = false
-      end
-
-      def before_examples(_examples)
-        builder << '<div class="examples">'
-      end
-
-      def after_examples(_examples)
-        builder << '</div>'
-      end
-
-      def examples_name(keyword, name)
-        builder.h4 do
-          builder.span(keyword, :class => 'keyword')
-          builder.text!(' ')
-          builder.span(name, :class => 'val')
-        end
-      end
+      def initialize(config)
+        @io = ensure_io(config.out_stream)
+        @html_formatter = Cucumber::HTMLFormatter::Formatter.new(@io)
+        @html_formatter.write_pre_message
 
-      def before_steps(_steps)
-        builder << '<ol>'
+        super(config)
       end
 
-      def after_steps(_steps)
-        print_messages
-        builder << '</ol>' if @in_background or @in_scenario_outline
-      end
-
-      def before_step(step)
-        print_messages
-        @step_id = step.dom_id
-        @step_number += 1
-        @step = step
-      end
-
-      def after_step(_step)
-        move_progress
-      end
-
-      def before_step_result(_keyword, step_match, _multiline_arg, status, exception, _source_indent, background, _file_colon_line)
-        @step_match = step_match
-        @hide_this_step = false
-        if exception
-          if @exceptions.include?(exception)
-            @hide_this_step = true
-            return
-          end
-          @exceptions << exception
-        end
-        if status != :failed && @in_background ^ background
-          @hide_this_step = true
-          return
-        end
-        @status = status
-        return if @hide_this_step
-        set_scenario_color(status)
-        builder << "<li id='#{@step_id}' class='step #{status}'>"
-      end
-
-      def after_step_result(keyword, step_match, _multiline_arg, status, _exception, _source_indent, _background, _file_colon_line)
-        return if @hide_this_step
-        # print snippet for undefined steps
-        unless outline_step?(@step)
-          keyword = @step.actual_keyword(@previous_step_keyword)
-          @previous_step_keyword = keyword
-        end
-        if status == :undefined
-          builder.pre do |pre|
-            # TODO: snippet text should be an event sent to the formatter so we don't
-            # have this couping to the runtime.
-            pre << @runtime.snippet_text(keyword,step_match.instance_variable_get('@name') || '', @step.multiline_arg)
-          end
-        end
-        builder << '</li>'
-        print_messages
-      end
-
-      def step_name(keyword, step_match, status, _source_indent, background, _file_colon_line)
-        background_in_scenario = background && !@listing_background
-        @skip_step = background_in_scenario
-
-        unless @skip_step
-          build_step(keyword, step_match, status)
-        end
-      end
-
-      def exception(exception, _status)
-        return if @hide_this_step
-        print_messages
-        build_exception_detail(exception)
-      end
-
-      def extra_failure_content(file_colon_line)
-        @snippet_extractor ||= SnippetExtractor.new
-        "<pre class=\"ruby\"><code>#{@snippet_extractor.snippet(file_colon_line)}</code></pre>"
-      end
-
-      def before_multiline_arg(multiline_arg)
-        return if @hide_this_step || @skip_step
-        if AST_DATA_TABLE === multiline_arg
-          builder << '<table>'
-        end
-      end
-
-      def after_multiline_arg(multiline_arg)
-        return if @hide_this_step || @skip_step
-        if AST_DATA_TABLE === multiline_arg
-          builder << '</table>'
-        end
-      end
-
-      def doc_string(string)
-        return if @hide_this_step
-        builder.pre(:class => 'val') do |pre|
-          builder << h(string).gsub("\n", '&#x000A;')
-        end
-      end
-
-      def before_table_row(table_row)
-        @row_id = table_row.dom_id
-        @col_index = 0
-        return if @hide_this_step
-        builder << "<tr class='step' id='#{@row_id}'>"
-      end
-
-      def after_table_row(table_row)
-        return if @hide_this_step
-        print_table_row_messages
-        builder << '</tr>'
-        if table_row.exception
-          builder.tr do
-            builder.td(:colspan => @col_index.to_s, :class => 'failed') do
-              builder.pre do |pre|
-                pre << h(format_exception(table_row.exception))
-              end
-            end
-          end
-          if table_row.exception.is_a? ::Cucumber::Pending
-            set_scenario_color_pending
-          else
-            set_scenario_color_failed
-          end
-        end
-        if @outline_row
-          @outline_row += 1
-        end
-        @step_number += 1
-        move_progress
-      end
-
-      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 => 'step'}
-        attributes[:class] += " #{status}" if status
-        build_cell(@cell_type, value, attributes)
-        set_scenario_color(status) if @inside_outline
-        @col_index += 1
-      end
-
-      def puts(message)
-        @delayed_messages << message
-        #builder.pre(message, :class => 'message')
-      end
-
-      def print_messages
-        return if @delayed_messages.empty?
-
-        #builder.ol do
-          @delayed_messages.each do |ann|
-            builder.li(:class => 'step message') do
-              builder << ann
-            end
-          end
-        #end
-        empty_messages
-      end
-
-      def print_table_row_messages
-        return if @delayed_messages.empty?
-
-        builder.td(:class => 'message') do
-          builder << @delayed_messages.join(', ')
-        end
-        empty_messages
-      end
-
-      def empty_messages
-        @delayed_messages = []
-      end
-
-      def after_test_case(_test_case, result)
-        if result.failed? and not @scenario_red
-          set_scenario_color_failed
-        end
-      end
-
-      protected
-
-      def next_id(type)
-        @indices ||= Hash.new { 0 }
-        @indices[type] += 1
-        "#{type}_#{@indices[:type]}"
-      end
-
-      def build_exception_detail(exception)
-        backtrace = Array.new
-
-        builder.div(:class => 'message') do
-          message = exception.message
-
-          if defined?(RAILS_ROOT) && message.include?('Exception caught')
-            matches = message.match(/Showing <i>(.+)<\/i>(?:.+) #(\d+)/)
-            backtrace += ["#{RAILS_ROOT}/#{matches[1]}:#{matches[2]}"] if matches
-            matches = message.match(/<code>([^(\/)]+)<\//m)
-            message = matches ? matches[1] : ''
-          end
-
-          unless exception.instance_of?(RuntimeError)
-            message = "#{message} (#{exception.class})"
-          end
-
-          builder.pre do
-            builder.text!(message)
-          end
-        end
-
-        builder.div(:class => 'backtrace') do
-          builder.pre do
-            backtrace = exception.backtrace
-            backtrace.delete_if { |x| x =~ /\/gems\/(cucumber|rspec)/ }
-            builder << backtrace_line(backtrace.join("\n"))
-          end
-        end
-
-        extra = extra_failure_content(backtrace)
-        builder << extra unless extra == ''
-      end
-
-      def set_scenario_color(status)
-        if status.nil? or status == :undefined or status == :pending
-          set_scenario_color_pending
-        end
-        if status == :failed
-          set_scenario_color_failed
-        end
-      end
-
-      def set_scenario_color_failed
-        builder.script do
-          builder.text!("makeRed('cucumber-header');") unless @header_red
-          @header_red = true
-          scenario_or_background = @in_background ? 'background' : 'scenario'
-          builder.text!("makeRed('#{scenario_or_background}_#{@scenario_number}');") unless @scenario_red
-          @scenario_red = true
-          if @options[:expand] and @inside_outline
-            builder.text!("makeRed('#{scenario_or_background}_#{@scenario_number}_#{@outline_row}');")
-          end
-        end
-      end
-
-      def set_scenario_color_pending
-        builder.script do
-          builder.text!("makeYellow('cucumber-header');") unless @header_red
-          scenario_or_background = @in_background ? 'background' : 'scenario'
-          builder.text!("makeYellow('#{scenario_or_background}_#{@scenario_number}');") unless @scenario_red
-        end
-      end
-
-      def build_step(keyword, step_match, _status)
-        step_name = step_match.format_args(lambda{|param| %{<span class="param">#{param}</span>}})
-        builder.div(:class => 'step_name') do |div|
-          builder.span(keyword, :class => 'keyword')
-          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
-
-        step_file = step_match.file_colon_line
-        step_file.gsub(/^([^:]*\.rb):(\d*)/) do
-          if ENV['TM_PROJECT_DIRECTORY']
-            step_file = "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
-          end
-        end
-
-        builder.div(:class => 'step_file') do |div|
-          builder.span do
-            builder << step_file
-          end
-        end
-      end
-
-      def build_cell(cell_type, value, attributes)
-        builder.__send__(cell_type, attributes) do
-          builder.div do
-            builder.span(value,:class => 'step param')
-          end
-        end
-      end
-
-      def move_progress
-        builder << " <script type=\"text/javascript\">moveProgressBar('#{percent_done}');</script>"
-      end
-
-      def percent_done
-        result = 100.0
-        if @step_count != 0
-          result = ((@step_number).to_f / @step_count.to_f * 1000).to_i / 10.0
-        end
-        result
-      end
-
-      def format_exception(exception)
-        ([exception.message.to_s] + exception.backtrace).join("\n")
-      end
-
-      def backtrace_line(line)
-        if ENV['TM_PROJECT_DIRECTORY']
-          line.gsub(/^([^:]*\.(?:rb|feature|haml)):(\d*).*$/) do
-            "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
-          end
-        else
-          line
-        end
-      end
-
-      def print_stats(features)
-        builder <<  "<script type=\"text/javascript\">document.getElementById('duration').innerHTML = \"Finished in <strong>#{format_duration(features.duration)} seconds</strong>\";</script>"
-        builder <<  "<script type=\"text/javascript\">document.getElementById('totals').innerHTML = \"#{print_stat_string(features)}\";</script>"
-      end
-
-      def print_stat_string(_features)
-        string = String.new
-        string << dump_count(@runtime.scenarios.length, 'scenario')
-        scenario_count = print_status_counts{|status| @runtime.scenarios(status)}
-        string << scenario_count if scenario_count
-        string << '<br />'
-        string << dump_count(@runtime.steps.length, 'step')
-        step_count = print_status_counts{|status| @runtime.steps(status)}
-        string << step_count if step_count
-      end
-
-      def print_status_counts
-        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
-          elements = yield status
-          elements.any? ? "#{elements.length} #{status}" : nil
-        end.compact
-        return " (#{counts.join(', ')})" if counts.any?
-      end
-
-      def dump_count(count, what, state=nil)
-        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(' ')
-      end
-
-      def outline_step?(_step)
-        not @step.step.respond_to?(:actual_keyword)
-      end
-
-      class SnippetExtractor #:nodoc:
-        class NullConverter; def convert(code, _pre); code; end; end #:nodoc:
-
-        begin
-          require 'syntax/convertors/html'
-          @@converter = Syntax::Convertors::HTML.for_syntax 'ruby'
-        rescue LoadError
-          @@converter = NullConverter.new
-        end
-
-        def snippet(error)
-          raw_code, line = snippet_for(error[0])
-          highlighted = @@converter.convert(raw_code, false)
-          highlighted << "\n<span class=\"comment\"># gem install syntax to get syntax highlighting</span>" if @@converter.is_a?(NullConverter)
-          post_process(highlighted, line)
-        end
-
-        def snippet_for(error_line)
-          if error_line =~ /(.*):(\d+)/
-            file = $1
-            line = $2.to_i
-            [lines_around(file, line), line]
-          else
-            ["# Couldn't get snippet for #{error_line}", 1]
-          end
-        end
-
-        def lines_around(file, line)
-          if File.file?(file)
-            begin
-            lines = File.open(file).read.split("\n")
-          rescue ArgumentError
-            return "# Couldn't get snippet for #{file}"
-          end
-          min = [0, line-3].max
-            max = [line+1, lines.length-1].min
-            selected_lines = []
-            selected_lines.join("\n")
-            lines[min..max].join("\n")
-          else
-            "# Couldn't get snippet for #{file}"
-          end
-        end
-
-        def post_process(highlighted, offending_line)
-          new_lines = []
-          highlighted.split("\n").each_with_index do |line, i|
-            new_line = "<span class=\"linenum\">#{offending_line+i-2}</span>#{line}"
-            new_line = "<span class=\"offending\">#{new_line}</span>" if i == 2
-            new_lines << new_line
-          end
-          new_lines.join("\n")
-        end
-
+      def output_envelope(envelope)
+        @html_formatter.write_message(envelope)
+        @html_formatter.write_post_message if envelope.test_run_finished
       end
     end
   end