cucumber 3.0.0.pre.1 → 3.0.0.pre.2

data/lib/cucumber/formatter/backtrace_filter.rb

@@ -4,13 +4,25 @@ require 'cucumber/platform'
 
 module Cucumber
   module Formatter
-    BACKTRACE_FILTER_PATTERNS = \
-      [/vendor\/rails|lib\/cucumber|bin\/cucumber:|lib\/rspec|gems\/|minitest|test\/unit|.gem\/ruby|lib\/ruby/]
-
-    if(::Cucumber::JRUBY)
-      BACKTRACE_FILTER_PATTERNS << /org\/jruby/
+    @backtrace_filters = %w(
+      /vendor/rails
+      lib/cucumber
+      bin/cucumber:
+      lib/rspec
+      gems/
+      minitest
+      test/unit
+      .gem/ruby
+      lib/ruby/
+      bin/bundle
+    )
+
+    if ::Cucumber::JRUBY
+      @backtrace_filters << 'org/jruby/'
     end
 
+    BACKTRACE_FILTER_PATTERNS = Regexp.new(@backtrace_filters.join('|'))
+
     class BacktraceFilter
       def initialize(exception)
         @exception = exception
@@ -20,10 +32,10 @@ module Cucumber
         return @exception if ::Cucumber.use_full_backtrace
 
         pwd_pattern = /#{::Regexp.escape(::Dir.pwd)}\//m
-        backtrace = @exception.backtrace.map { |line| line.gsub(pwd_pattern, "./") }
+        backtrace = @exception.backtrace.map { |line| line.gsub(pwd_pattern, './') }
 
         filtered = (backtrace || []).reject do |line|
-          BACKTRACE_FILTER_PATTERNS.detect { |p| line =~ p }
+          line =~ BACKTRACE_FILTER_PATTERNS
         end
 
         if ::ENV['CUCUMBER_TRUNCATE_OUTPUT']

data/lib/cucumber/formatter/console.rb

@@ -32,11 +32,11 @@ module Cucumber
 
       def format_step(keyword, step_match, status, source_indent)
         comment = if source_indent
-          c = ('# ' + step_match.location.to_s).indent(source_indent)
-          format_string(c, :comment)
-        else
-          ''
-        end
+                    c = ('# ' + step_match.location.to_s).indent(source_indent)
+                    format_string(c, :comment)
+                  else
+                    ''
+                  end
 
         format = format_for(status, :param)
         line = keyword + step_match.format_args(format) + comment
@@ -102,10 +102,10 @@ module Cucumber
       end
 
       def exception_message_string(e, indent)
-        message = "#{e.message} (#{e.class})".dup.force_encoding("UTF-8")
+        message = "#{e.message} (#{e.class})".dup.force_encoding('UTF-8')
         message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
 
-        string = "#{message}\n#{e.backtrace.join("\n")}".indent(indent)
+        "#{message}\n#{e.backtrace.join("\n")}".indent(indent)
       end
 
       # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/10655
@@ -116,13 +116,11 @@ module Cucumber
 
       def collect_snippet_data(test_step, result)
         # collect snippet data for undefined steps
-        unless hook?(test_step)
-          keyword = test_step.source.last.actual_keyword(@previous_step_keyword)
-          @previous_step_keyword = keyword
-          if result.undefined?
-            @snippets_input << Console::SnippetData.new(keyword, test_step.source.last)
-          end
-        end
+        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)
       end
 
       def print_snippets(options)
@@ -157,7 +155,7 @@ module Cucumber
       def do_print_passing_wip(passed_messages)
         if passed_messages.any?
           @io.puts format_string("\nThe --wip switch was used, so I didn't expect anything to pass. These scenarios passed:", :failed)
-          print_element_messages(passed_messages, :passed, "scenarios")
+          print_element_messages(passed_messages, :passed, 'scenarios')
         else
           @io.puts format_string("\nThe --wip switch was used, so the failures were expected. All is good.\n", :passed)
         end
@@ -210,7 +208,6 @@ module Cucumber
       end
 
       def do_print_profile_information(profiles)
-        profiles_sentence = ''
         profiles_sentence = profiles.size == 1 ? profiles.first :
           "#{profiles[0...-1].join(', ')} and #{profiles.last}"
 
@@ -233,11 +230,11 @@ module Cucumber
       end
 
       def element_messages(elements, status)
-        element_messages = elements.map do |element|
+        elements.map do |element|
           if status == :failed
-            message = exception_message_string(element.exception, 0)
+            exception_message_string(element.exception, 0)
           else
-            message = linebreaks(element.backtrace_line, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
+            linebreaks(element.backtrace_line, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
           end
         end
       end

data/lib/cucumber/formatter/console_counts.rb

@@ -6,43 +6,30 @@ module Cucumber
       include Console
 
       def initialize(config)
-        @test_case_summary = Core::Test::Result::Summary.new
-        @test_step_summary = Core::Test::Result::Summary.new
-
-        config.on_event :test_case_finished do |event|
-          event.result.describe_to @test_case_summary
-        end
-
-        config.on_event :test_step_finished do |event|
-          event.result.describe_to @test_step_summary if from_gherkin?(event.test_step)
-        end
+        @summary = Core::Report::Summary.new(config.event_bus)
       end
 
       def to_s
         [
-          [scenario_count, status_counts(@test_case_summary)].compact.join(" "),
-          [step_count, status_counts(@test_step_summary)].compact.join(" ")
+          [scenario_count, status_counts(@summary.test_cases)].compact.join(' '),
+          [step_count, status_counts(@summary.test_steps)].compact.join(' ')
         ].join("\n")
       end
 
       private
 
-      def from_gherkin?(test_step)
-        test_step.source.last.location.file.match(/\.feature$/)
-      end
-
       def scenario_count
-        count = @test_case_summary.total
-        "#{count} scenario" + (count == 1 ? "" : "s")
+        count = @summary.test_cases.total
+        "#{count} scenario" + (count == 1 ? '' : 's')
       end
 
       def step_count
-        count = @test_step_summary.total
-        "#{count} step" + (count == 1 ? "" : "s")
+        count = @summary.test_steps.total
+        "#{count} step" + (count == 1 ? '' : 's')
       end
 
       def status_counts(summary)
-        counts = [:failed, :skipped, :undefined, :pending, :passed].map { |status|
+        counts = Core::Test::Result::TYPES.map { |status|
           count = summary.total(status)
           [status, count]
         }.select { |status, count|

data/lib/cucumber/formatter/console_issues.rb

@@ -6,28 +6,49 @@ module Cucumber
       include Console
 
       def initialize(config)
-        @failures = []
+        @previous_test_case = nil
+        @issues = Hash.new { |h, k| h[k] = [] }
         @config = config
         @config.on_event(:test_case_finished) do |event|
-          @failures << event.test_case if event.result.failed?
+          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?)
+          elsif event.result.passed?
+            @issues[:flaky] << event.test_case unless Core::Test::Result::Flaky.ok?(@config.strict?)
+            @issues[:failed].delete(event.test_case)
+          end
         end
       end
 
       def to_s
-        return if @failures.empty?
-        result = [ format_string("Failing Scenarios:", :failed) ] + @failures.map { |failure|
-          source = @config.source? ? format_string(" # #{failure.keyword}: #{failure.name}", :comment) : ''
-          format_string("cucumber #{profiles_string}" + failure.location, :failed) + source
-        }
-        result.join("\n")
+        return if @issues.empty?
+        result = Core::Test::Result::TYPES.map { |type| scenario_listing(type, @issues[type]) }
+        result.flatten.join("\n")
       end
 
       def any?
-        @failures.any?
+        @issues.any?
       end
 
       private
 
+      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
+        }
+      end
+
+      def type_heading(type)
+        case type
+        when :failed
+          'Failing'
+        else
+          type.to_s.slice(0, 1).capitalize + type.to_s.slice(1..-1)
+        end
+      end
+
       def profiles_string
         return if @config.custom_profiles.empty?
         @config.custom_profiles.map { |profile| "-p #{profile}" }.join(' ') + ' '

data/lib/cucumber/formatter/duration.rb

@@ -7,7 +7,7 @@ module Cucumber
       # <tt>time</tt> format.
       def format_duration(seconds)
         m, s = seconds.divmod(60)
-        "#{m}m#{'%.3f' % s}s"
+        "#{m}m#{format('%.3f', s)}s"
       end
     end
   end

data/lib/cucumber/formatter/fail_fast.rb

@@ -9,7 +9,7 @@ module Cucumber
 
       def initialize(configuration)
         configuration.on_event :test_case_finished do |event|
-          test_case, result = *event.attributes
+          _test_case, result = *event.attributes
           Cucumber.wants_to_quit = true unless result.ok?(configuration.strict?)
         end
       end

data/lib/cucumber/formatter/html.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 require 'erb'
-require 'builder'
 require 'cucumber/formatter/duration'
 require 'cucumber/formatter/io'
+require 'cucumber/formatter/html_builder'
 require 'pathname'
 
 module Cucumber
@@ -14,174 +14,142 @@ module Cucumber
         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
       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 = create_builder(@io)
+        @builder = HtmlBuilder.new(target: @io, indent: 0)
         @feature_number = 0
         @scenario_number = 0
         @step_number = 0
         @header_red = nil
         @delayed_messages = []
-        @img_id = 0
-        @text_id = 0
-        @inside_outline = false
+        @inside_outline        = false
         @previous_step_keyword = nil
       end
 
       def embed(src, mime_type, label)
-        case(mime_type)
-        when /^image\/(png|gif|jpg|jpeg)/
-          unless File.file?(src) or src =~ /^data:image\/(png|gif|jpg|jpeg);base64,/
-            type = mime_type =~ /;base[0-9]+$/ ? mime_type : mime_type + ";base64"
-            src = "data:" + type + "," + src
-          end
-          embed_image(src, label)
-        when /^text\/plain/
-          embed_text(src, 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 embed_image(src, label)
-        id = "img_#{@img_id}"
-        @img_id += 1
+      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        
-        @builder.span(:class => 'embed') do |pre|
-          pre << %{<a href="" onclick="img=document.getElementById('#{id}'); img.style.display = (img.style.display == 'none' ? 'block' : 'none');return false">#{label}</a><br>&nbsp;
-          <img id="#{id}" style="display: none" src="#{src}"/>}
         end
+
+        src
       end
 
-      def embed_text(src, label)
-        id = "text_#{@text_id}"
-        @text_id += 1
-        @builder.span(:class => 'embed') do |pre|
-          pre << %{<a id="#{id}" href="#{src}" title="#{label}">#{label}</a>}
-        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!
 
-        # <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-        @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">'
-          @builder.head do
-          @builder.meta('http-equiv' => 'Content-Type', :content => 'text/html;charset=utf-8')
-          @builder.title 'Cucumber'
-          inline_css
-          inline_js
-        end
-        @builder << '<body>'
-        @builder << "<!-- Step count #{@step_count}-->"
-        @builder << '<div class="cucumber">'
-        @builder.div(:id => 'cucumber-header') do
-          @builder.div(:id => 'label') do
-            @builder.h1('Cucumber Features')
-          end
-          @builder.div(:id => 'summary') do
-            @builder.p('',:id => 'totals')
-            @builder.p('',:id => 'duration')
-            @builder.div(:id => 'expand-collapse') do
-              @builder.p('Expand All', :id => 'expander')
-              @builder.p('Collapse All', :id => 'collapser')
-            end
-          end
-        end
+        builder.build_document!
+        builder.format_features! features
       end
 
       def after_features(features)
         print_stats(features)
-        @builder << '</div>'
-        @builder << '</body>'
-        @builder << '</html>'
+        builder << '</div>'
+        builder << '</body>'
+        builder << '</html>'
       end
 
-      def before_feature(feature)
+      def before_feature(_feature)
         @exceptions = []
-        @builder << '<div class="feature">'
+        builder << '<div class="feature">'
       end
 
-      def after_feature(feature)
-        @builder << '</div>'
+      def after_feature(_feature)
+        builder << '</div>'
       end
 
-      def before_comment(comment)
-        @builder << '<pre class="comment">'
+      def before_comment(_comment)
+        builder << '<pre class="comment">'
       end
 
-      def after_comment(comment)
-        @builder << '</pre>'
+      def after_comment(_comment)
+        builder << '</pre>'
       end
 
       def comment_line(comment_line)
-        @builder.text!(comment_line)
-        @builder.br
+        builder.text!(comment_line)
+        builder.br
       end
 
-      def after_tags(tags)
+      def after_tags(_tags)
         @tag_spacer = nil
       end
 
       def tag_name(tag_name)
-        @builder.text!(@tag_spacer) if @tag_spacer
+        builder.text!(@tag_spacer) if @tag_spacer
         @tag_spacer = ' '
-        @builder.span(tag_name, :class => 'tag')
+        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')
+        builder.h2 do |h2|
+          builder.span(keyword + ': ' + 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 before_test_case(test_case)
+      def before_test_case(_test_case)
         @previous_step_keyword = nil
       end
 
-      def before_background(background)
+      def before_background(_background)
         @in_background = true
-        @builder << '<div class="background">'
+        builder << '<div class="background">'
       end
 
-      def after_background(background)
+      def after_background(_background)
         @in_background = nil
-        @builder << '</div>'
+        builder << '</div>'
       end
 
-      def background_name(keyword, name, file_colon_line, source_indent)
+      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')
+        builder.h3(:id => "background_#{@scenario_number}") do |h3|
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(name, :class => 'val')
         end
       end
 
@@ -189,22 +157,22 @@ module Cucumber
         @scenario_number+=1
         @scenario_red = false
         css_class = AST_CLASSES[feature_element.class]
-        @builder << "<div class='#{css_class}'>"
+        builder << "<div class='#{css_class}'>"
         @in_scenario_outline = feature_element.class == Cucumber::Core::Ast::ScenarioOutline
       end
 
-      def after_feature_element(feature_element)
+      def after_feature_element(_feature_element)
         unless @in_scenario_outline
           print_messages
-          @builder << '</ol>'
+          builder << '</ol>'
         end
-        @builder << '</div>'
+        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
+      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}"
@@ -213,48 +181,48 @@ module Cucumber
           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')
+        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)
+      def before_outline_table(_outline_table)
         @inside_outline = true
         @outline_row = 0
-        @builder << '<table>'
+        builder << '<table>'
       end
 
-      def after_outline_table(outline_table)
-        @builder << '</table>'
+      def after_outline_table(_outline_table)
+        builder << '</table>'
         @outline_row = nil
         @inside_outline = false
       end
 
-      def before_examples(examples)
-        @builder << '<div class="examples">'
+      def before_examples(_examples)
+        builder << '<div class="examples">'
       end
 
-      def after_examples(examples)
-        @builder << '</div>'
+      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')
+        builder.h4 do
+          builder.span(keyword, :class => 'keyword')
+          builder.text!(' ')
+          builder.span(name, :class => 'val')
         end
       end
 
-      def before_steps(steps)
-        @builder << '<ol>'
+      def before_steps(_steps)
+        builder << '<ol>'
       end
 
-      def after_steps(steps)
+      def after_steps(_steps)
         print_messages
-        @builder << '</ol>' if @in_background or @in_scenario_outline
+        builder << '</ol>' if @in_background or @in_scenario_outline
       end
 
       def before_step(step)
@@ -264,11 +232,11 @@ module Cucumber
         @step = step
       end
 
-      def after_step(step)
+      def after_step(_step)
         move_progress
       end
 
-      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+      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
@@ -285,10 +253,10 @@ module Cucumber
         @status = status
         return if @hide_this_step
         set_scenario_color(status)
-        @builder << "<li id='#{@step_id}' class='step #{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)
+      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)
@@ -296,17 +264,17 @@ module Cucumber
           @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 
+          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)
+            pre << @runtime.snippet_text(keyword,step_match.instance_variable_get('@name') || '', @step.multiline_arg)
           end
         end
-        @builder << '</li>'
+        builder << '</li>'
         print_messages
       end
 
-      def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
+      def step_name(keyword, step_match, status, _source_indent, background, _file_colon_line)
         background_in_scenario = background && !@listing_background
         @skip_step = background_in_scenario
 
@@ -315,7 +283,7 @@ module Cucumber
         end
       end
 
-      def exception(exception, status)
+      def exception(exception, _status)
         return if @hide_this_step
         print_messages
         build_exception_detail(exception)
@@ -329,21 +297,21 @@ module Cucumber
       def before_multiline_arg(multiline_arg)
         return if @hide_this_step || @skip_step
         if AST_DATA_TABLE === multiline_arg
-          @builder << '<table>'
+          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>'
+          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;')
+        builder.pre(:class => 'val') do |pre|
+          builder << h(string).gsub("\n", '&#x000A;')
         end
       end
 
@@ -351,17 +319,17 @@ module Cucumber
         @row_id = table_row.dom_id
         @col_index = 0
         return if @hide_this_step
-        @builder << "<tr class='step' id='#{@row_id}'>"
+        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>'
+        builder << '</tr>'
         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 << h(format_exception(table_row.exception))
               end
             end
@@ -392,16 +360,16 @@ module Cucumber
 
       def puts(message)
         @delayed_messages << message
-        #@builder.pre(message, :class => 'message')
+        #builder.pre(message, :class => 'message')
       end
 
       def print_messages
         return if @delayed_messages.empty?
 
-        #@builder.ol do
+        #builder.ol do
           @delayed_messages.each do |ann|
-            @builder.li(:class => 'step message') do
-              @builder << ann
+            builder.li(:class => 'step message') do
+              builder << ann
             end
           end
         #end
@@ -411,8 +379,8 @@ module Cucumber
       def print_table_row_messages
         return if @delayed_messages.empty?
 
-        @builder.td(:class => 'message') do
-          @builder << @delayed_messages.join(", ")
+        builder.td(:class => 'message') do
+          builder << @delayed_messages.join(', ')
         end
         empty_messages
       end
@@ -421,7 +389,7 @@ module Cucumber
         @delayed_messages = []
       end
 
-      def after_test_case(test_case, result)
+      def after_test_case(_test_case, result)
         if result.failed? and not @scenario_red
           set_scenario_color_failed
         end
@@ -429,34 +397,44 @@ module Cucumber
 
       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
+
+        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] : ""
+            message = matches ? matches[1] : ''
           end
 
           unless exception.instance_of?(RuntimeError)
             message = "#{message} (#{exception.class})"
           end
 
-          @builder.pre do
-            @builder.text!(message)
+          builder.pre do
+            builder.text!(message)
           end
         end
-        @builder.div(:class => 'backtrace') do
-          @builder.pre do
+
+        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"))
+            builder << backtrace_line(backtrace.join("\n"))
           end
         end
+
         extra = extra_failure_content(backtrace)
-        @builder << extra unless extra == ""
+        builder << extra unless extra == ''
       end
 
       def set_scenario_color(status)
@@ -469,31 +447,31 @@ module Cucumber
       end
 
       def set_scenario_color_failed
-        @builder.script do
-          @builder.text!("makeRed('cucumber-header');") unless @header_red
+        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_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}');")
+            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
+        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)
+      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|
+        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
@@ -505,77 +483,23 @@ module Cucumber
           end
         end
 
-        @builder.div(:class => 'step_file') do |div|
-          @builder.span do
-            @builder << step_file
+        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')
+        builder.__send__(cell_type, attributes) do
+          builder.div do
+            builder.span(value,:class => 'step param')
           end
         end
       end
 
-      def inline_css
-        @builder.style(:type => 'text/css') do
-          @builder << File.read(File.dirname(__FILE__) + '/cucumber.css')
-        end
-      end
-
-      def inline_js
-        @builder.script(:type => 'text/javascript') do
-          @builder << inline_jquery
-          @builder << inline_js_content
-        end
-      end
-
-      def inline_jquery
-        File.read(File.dirname(__FILE__) + '/jquery-min.js')
-      end
-
-      def inline_js_content
-        <<-EOF
-
-  SCENARIOS = "h3[id^='scenario_'],h3[id^=background_]";
-
-  $(document).ready(function() {
-    $(SCENARIOS).css('cursor', 'pointer');
-    $(SCENARIOS).click(function() {
-      $(this).siblings().toggle(250);
-    });
-
-    $("#collapser").css('cursor', 'pointer');
-    $("#collapser").click(function() {
-      $(SCENARIOS).siblings().hide();
-    });
-
-    $("#expander").css('cursor', 'pointer');
-    $("#expander").click(function() {
-      $(SCENARIOS).siblings().show();
-    });
-  })
-
-  function moveProgressBar(percentDone) {
-    $("cucumber-header").css('width', percentDone +"%");
-  }
-  function makeRed(element_id) {
-    $('#'+element_id).css('background', '#C40D0D');
-    $('#'+element_id).css('color', '#FFFFFF');
-  }
-  function makeYellow(element_id) {
-    $('#'+element_id).css('background', '#FAF834');
-    $('#'+element_id).css('color', '#000000');
-  }
-
-        EOF
-      end
-
       def move_progress
-        @builder << " <script type=\"text/javascript\">moveProgressBar('#{percent_done}');</script>"
+        builder << " <script type=\"text/javascript\">moveProgressBar('#{percent_done}');</script>"
       end
 
       def percent_done
@@ -587,10 +511,10 @@ module Cucumber
       end
 
       def format_exception(exception)
-        (["#{exception.message}"] + exception.backtrace).join("\n")
+        ([exception.message.to_s] + exception.backtrace).join("\n")
       end
 
-     def backtrace_line(line)
+      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> "
@@ -601,17 +525,17 @@ module Cucumber
       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>"
+        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)
+      def print_stat_string(_features)
         string = String.new
-        string << dump_count(@runtime.scenarios.length, "scenario")
+        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")
+        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
@@ -619,26 +543,28 @@ module Cucumber
       def print_status_counts
         counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
           elements = yield status
-          elements.any? ? "#{elements.length} #{status.to_s}" : nil
+          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 create_builder(io)
-        Builder::XmlMarkup.new(:target => io, :indent => 0)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(' ')
       end
 
-      def outline_step?(step)
+      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 => e; @@converter = NullConverter.new; end
+        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])