cucumber 0.4.4 → 0.4.5.rc1

data/lib/cucumber/formatter/cucumber.sass

@@ -1,49 +1,70 @@
-# cucumber.css is generated from cucumber.sass
-# Regenerate with rake sass
+/* cucumber.css is generated from cucumber.sass */
+/* Regenerate with rake sass */
 
-!step_left   = 5px solid
-!step_bottom = 1px solid
+!step_left        = 5px "solid"
+!step_bottom      = 1px "solid"
 
-!failed         = #FFC0CB
-!failed_dark    = #FF0000
-!failed_text    = #8B0000
+!failed           = #FFFBD3
+!failed_border    = #C20000
+!failed_text      = #C20000
 
-!passed         = #98FB98
-!passed_dark    = #00FF00
-!passed_text    = #001111
+!passed           = #DBFFB4
+!passed_border    = #65C400
+!passed_text      = #3D7700
 
-!skipped        = #E0FFFF
-!skipped_dark   = #00FFFF
-!skipped_text   = #001111
+!skipped          = #E0FFFF
+!skipped_border   = #00FFFF
+!skipped_text     = #001111
 
-!pending        = #FFFF00
-!pending_dark   = #FF8000
-!pending_text   = #2A1B0A
+!pending          = #FCFB98
+!pending_border   = #FAF834
+!pending_text     = #131313
 
-!undefined      = #FFFF00
-!undefined_dark = #FF8000
-!undefined_text = #2A1B0A
+!undefined        = #FCFB98
+!undefined_border = #FAF834
+!undefined_text   = #131313
 
-.cucumber
-  :font-family "Lucida Grande", Helvetica, sans-serif
-  :font-size 0.7em
+body
+  :font-size 0px
+  :color #FFFFFF
+  :margin 0px
+  :padding 0px
+
+.cucumber,td,th
+  :font normal 11px "Lucida Grande", Helvetica, sans-serif
   :background white
-  :padding 1em
+  :color #000000
   
-  h1, h2, h3, h4, ol, li, pre, p
-    :font-size 1em
-    :padding 0px
-    :margin 0px
+  #cucumber-header
+    :background #65C400
+    :color #FFFFFF
+    :height 5em
+    
+  .scenario
+    h3
+      :font-size 11px
+      :padding 3px
+      :margin 0
+      :background #65C400
+      :color #FFFFFF
+      :font-weight bold
+  
+  h1
+    :margin 0px 10px 0px 10px
+    :padding 10px
+    :font-family "Lucida Grande", Helvetica, sans-serif
+    :font-size 1.8em
+    :position absolute
+  
+  h4
+    :margin-bottom 2px
 
   div.feature
-    :border 1px solid 
     :padding 2px
-    :margin 4px
+    :margin 0px 10px 5px 10px
 
-    div.background, div.scenario, p
-      :padding 0em 0em 0em 1em
-      div.examples
-        :padding 0em 0em 0em 1em
+  div.examples
+    :padding 0em 0em 0em 1em
 
   .stats
     :margin 2em
@@ -53,14 +74,19 @@
       li
         :display inline
 
+  .tag
+    :font-weight bold
+    :color #246AC1
+    
   .backtrace
     :margin-top 0
     :margin-bottom 0
     :margin-left 1em
+    :color #000000
 
   a
     :text-decoration none
-    :color inherit
+    :color #BE5C00
 
     &:hover
       :text-decoration underline
@@ -68,72 +94,148 @@
       :font-weight normal
 
     div.examples
-      :border 1px solid 
-      :padding 2px
-      :margin 4px
+      :margin 5px 0px 5px 15px
+      :color #000000
+      
+  .outline
+    table
+      :margin 0px 0px 5px 10px
 
   table
     :border-collapse collapse
-    
-    td, th
-      :font-size 0.7em
-      :border 1px solid #AAAAAA
+    td
+      :padding 3px 3px 3px 5px
+    td.failed, td.passed, td.skipped, td.pending, td.undefined
+      :padding-left 18px
+      :padding-right 10px
     td.failed
-      :background #FFC0CB
-      :color #8B0000
+      :border-left= !step_left !failed_border
+      :border-bottom= !step_bottom !failed_border
+      :background= !failed
+      :color= !failed_text
     td.passed
-      :background #98FB98
+      :border-left= !step_left !passed_border
+      :border-bottom= !step_bottom !passed_border
+      :background= !passed
       :color= !passed_text
     td.skipped
+      :border-left= !step_left !skipped_border
+      :border-bottom= !step_bottom !skipped_border
       :background= !skipped
       :color= !skipped_text
     td.pending
-      :background #FFFFE0
-      :color #111100
+      :border-left= !step_left !pending_border
+      :border-bottom= !step_bottom !pending_border
+      :background= !pending
+      :color= !pending_text
     td.undefined
-      :background #FFFFE0
-      :color #111100
+      :border-left= !step_left !undefined_border
+      :border-bottom= !step_bottom !undefined_border
+      :background= !undefined
+      :color= !undefined_text
 
   ol
     :list-style none
-  
+    :margin 0px
+    :padding 0px
+    
+    li.step
+      :padding 3px 3px 3px 18px
+      :margin 5px 0px 5px 5px
     li
       :margin 0em 0em 0em 1em
-      :padding 0em 0em 0em 0.2em
+      :padding 0em 0em 0em 0.2em        
       span.param
-        :font-weight bold
+        :font-weight bold      
     li.failed
-      :border-left= !step_left !failed_dark
-      :border-bottom= !step_bottom !failed_dark
+      :border-left= !step_left !failed_border
+      :border-bottom= !step_bottom !failed_border
       :background= !failed
       :color= !failed_text
-      span.param
-        :background !failed_dark
     li.passed
-      :border-left= !step_left !passed_dark
-      :border-bottom= !step_bottom !passed_dark
+      :border-left= !step_left !passed_border
+      :border-bottom= !step_bottom !passed_border
       :background= !passed
       :color= !passed_text
-      span.param
-        :background= !passed_dark
     li.skipped
-      :border-left= !step_left !skipped_dark
-      :border-bottom= !step_bottom !skipped_dark
+      :border-left= !step_left !skipped_border
+      :border-bottom= !step_bottom !skipped_border
       :background= !skipped
       :color= !skipped_text
-      span.param
-        :background= !skipped_dark
     li.pending
-      :border-left= !step_left !pending_dark
-      :border-bottom= !step_bottom !pending_dark
+      :border-left= !step_left !pending_border
+      :border-bottom= !step_bottom !pending_border
       :background= !pending
       :color= !pending_text
-      span.param
-        :background= !pending_dark
     li.undefined
-      :border-left= !step_left !undefined_dark
-      :border-bottom= !step_bottom !undefined_dark
+      :border-left= !step_left !undefined_border
+      :border-bottom= !step_bottom !undefined_border
       :background= !undefined
       :color= !undefined_text
-      span.param
-        :background= !undefined_dark
+            
+  #summary
+    :margin 0px
+    :padding 5px 10px
+    :text-align right
+    :top 0px
+    :right 0px
+    :float right
+
+    p
+      :margin 0 0 0 2px
+
+    #totals
+      :font-size 1.2em      
+      
+.ruby
+  :font-size 12px
+  :font-family monospace
+  :color white
+  :background black
+  :padding 0.1em 0 0.2em 0
+
+  .keyword 
+    :color #FF6600
+  .constant
+    :color #339999
+  .attribute
+    :color white
+  .global
+    :color white
+  .module
+    :color white
+  .class
+    :color white
+  .string
+    :color #66FF00
+  .ident
+    :color white
+  .method
+    :color #FFCC00
+  .number
+    :color white
+  .char
+    :color white
+  .comment
+    :color #9933CC
+  .symbol
+    :color white
+  .regex
+    :color #44B4CC
+  .punct
+    :color white
+  .escape
+    :color white
+  .interp 
+    :color white
+  .expr 
+    :color white
+
+  .offending
+    :background #333333
+  .linenum
+    :width 75px
+    :padding 0.1em 1em 0.2em 0
+    :color #000000
+    :background #FFFBD3
+

data/lib/cucumber/formatter/html.rb

@@ -1,203 +1,201 @@
 require 'cucumber/formatter/ordered_xml_markup'
 require 'cucumber/formatter/duration'
-require 'cucumber/formatter/summary'
+require 'cucumber/formatter/io'
 
 module Cucumber
   module Formatter
-    # The formatter used for <tt>--format html</tt>
     class Html
       include ERB::Util # for the #h method
       include Duration
-      include Summary
+      include Io
 
-      def initialize(step_mother, io, options)
-        @io = io
+      def initialize(step_mother, path_or_io, options)
+        @io = ensure_io(path_or_io, "html")
+        @step_mother = step_mother
         @options = options
         @buffer = {}
-        @step_mother = step_mother
-        @current_builder = create_builder(@io)
+        @builder = create_builder(@io)
+        @feature_number = 0
+        @scenario_number = 0
+        @step_number = 0
+        @header_red = nil
       end
-      
+
       def before_features(features)
-        start_buffering :features
-      end
-      
-      def after_features(features)
-        stop_buffering :features
+        @step_count = get_step_count(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', 
+          '-//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'
-            inline_css
+
+        @builder << '<html xmlns ="http://www.w3.org/1999/xhtml">'
+          @builder.head do
+          @builder.meta(: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.body do
-            builder.div(:class => 'cucumber') do
-              builder << buffer(:features)
-              builder.div(scenario_summary(@step_mother) {|status_count, _| status_count}, :class => 'summary')
-              builder.div(step_summary(@step_mother) {|status_count, _| status_count}, :class => 'summary')
-              builder.div(format_duration(features.duration), :class => 'duration')
-            end
+          @builder.div(:id => 'summary') do
+            @builder.p('',:id => 'totals')
+            @builder.p('',:id => 'duration')
           end
         end
       end
-      
+
+      def after_features(features)
+        print_stats(features)
+        @builder << '</div>'
+        @builder << '</body>'
+        @builder << '</html>'
+      end
+
       def before_feature(feature)
-        start_buffering :feature
         @exceptions = []
+        @builder << '<div class="feature">'
       end
-      
+
       def after_feature(feature)
-        stop_buffering :feature
-        builder.div(:class => 'feature') do
-          builder << buffer(:feature)
-        end
+        @builder << '</div>'
       end
-
+  
       def before_comment(comment)
-        start_buffering :comment
+        @builder << '<pre class="comment">'
       end
 
       def after_comment(comment)
-        stop_buffering :comment
-        builder.pre(:class => 'comment') do
-          builder << buffer(:comment)
-        end
+        @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)
         @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(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 before_background(background)
         @in_background = true
-        start_buffering :background
+        @builder << '<div class="background">'
       end
-      
+  
       def after_background(background)
-        stop_buffering :background
         @in_background = nil
-        builder.div(:class => 'background') do
-          builder << buffer(:background)
-        end
+        @builder << '</div>'
       end
-
+  
       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 before_feature_element(feature_element)
-        start_buffering :feature_element
-      end
-      
-      def after_feature_element(feature_element)
-        stop_buffering :feature_element
+        @scenario_number+=1
+        @scenario_red = false
         css_class = {
           Ast::Scenario        => 'scenario',
           Ast::ScenarioOutline => 'scenario outline'
-        }[feature_element.class]
+        }[feature_element.class]      
+        @builder << "<div class='#{css_class}'>"
+      end
 
-        builder.div(:class => css_class) do
-          builder << buffer(:feature_element)
-        end
+      def after_feature_element(feature_element)
+        @builder << '</div>'
         @open_step_list = true
       end
 
       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(:id => "scenario_#{@scenario_number}") do
+          @builder.span(keyword, :class => 'keyword')
+          @builder.text!(' ')
+          @builder.span(name, :class => 'val')
         end
       end
-      
+  
       def before_outline_table(outline_table)
         @outline_row = 0
-        start_buffering :outline_table
+        @builder << '<table>'
       end
-      
+  
       def after_outline_table(outline_table)
-        stop_buffering :outline_table
-        builder.table do
-          builder << buffer(:outline_table)
-        end
+        @builder << '</table>'
         @outline_row = nil
       end
-
+      
       def before_examples(examples)
-        start_buffering :examples
+         @builder << '<div class="examples">'
       end
       
       def after_examples(examples)
-        stop_buffering :examples
-        builder.div(:class => 'examples') do
-          builder << buffer(:examples)
-        end
+        @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)
-        start_buffering :steps
+        @builder << '<ol>'
       end
-      
+  
       def after_steps(steps)
-        stop_buffering :steps
-        builder.ol do
-          builder << buffer(:steps)
-        end
+        @builder << '</ol>'
       end
-      
+
       def before_step(step)
         @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)
-        start_buffering :step_result
+        @step_match = step_match
         @hide_this_step = false
         if exception
           if @exceptions.include?(exception)
@@ -211,14 +209,21 @@ module Cucumber
           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)
-        stop_buffering :step_result
         return if @hide_this_step
-        builder.li(:id => @step_id, :class => "step #{status}") do
-          builder << buffer(:step_result)
+        # print snippet for undefined steps
+        if status == :undefined
+          step_multiline_class = @step.multiline_arg ? @step.multiline_arg.class : nil
+          @builder.pre do |pre|
+            pre << @step_mother.snippet_text(keyword,step_match.instance_variable_get("@name") || '',step_multiline_class)
+          end
         end
+        @builder << '</li>'
       end
 
       def step_name(keyword, step_match, status, source_indent, background)
@@ -226,144 +231,315 @@ module Cucumber
         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 exception(exception, status)
-        return if @hide_this_step
-        builder.pre(format_exception(exception), :class => status)
+        build_exception_detail(exception)
       end
-      
-      def before_multiline_arg(multiline_arg)
-        start_buffering :multiline_arg
+
+      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::Table === multiline_arg
+          @builder << '<table>'
+        end
+      end
+  
       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
-            builder << buffer(:multiline_arg)
-          end
-        else
-          builder << buffer(:multiline_arg)
+          @builder << '</table>'
         end
       end
 
       def py_string(string)
         return if @hide_this_step
-        builder.pre(:class => 'val') do |pre|
-          builder << string.gsub("\n", '&#x000A;')
+        @builder.pre(:class => 'val') do |pre|
+          @builder << string.gsub("\n", '&#x000A;')
         end
       end
-
+  
+  
       def before_table_row(table_row)
         @row_id = table_row.dom_id
         @col_index = 0
-        start_buffering :table_row
+        return if @hide_this_step
+        @builder << "<tr class='step' id='#{@row_id}'>"
       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
+        @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 << format_exception(table_row.exception)
               end
             end
           end
         end
-        @outline_row += 1 if @outline_row
+        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 => 'val'}
+        @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)
+        build_cell(@cell_type, value, attributes)
+        set_scenario_color(status)
         @col_index += 1
       end
 
       def announce(announcement)
-        builder.pre(announcement, :class => 'announcement')
+        @builder.pre(announcement, :class => 'announcement')
       end
 
-      def embed(file, mime_type)
-        case(mime_type)
-        when /^image\/(png|gif|jpg)/
-          embed_image(file)
+      protected
+
+        def build_exception_detail(exception)
+          backtrace = Array.new
+          @builder.div(:class => 'message') do
+            message = exception.message
+            if message.include?('Exception caught')
+              matches = message.match(/Showing <i>(.+)<\/i>(?:.+)#(\d+)/)
+              backtrace += ["#{RAILS_ROOT}/#{matches[1]}:#{matches[2]}"]
+              message = message.match(/<code>([^(\/)]+)<\//m)[1]
+            end
+            @builder << "<pre>#{message}</pre>"
+          end
+          @builder.div(:class => 'backtrace') do
+            @builder.pre do
+              # backtrace += (exception.backtrace.size == 1 || exception.backtrace[0].include?('(eval):')) ? ["#{RAILS_ROOT}/#{@step_match.file_colon_line}"] + exception.backtrace : exception.backtrace
+              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
-      end
 
-      private
-      
-      def embed_image(file)
-        id = file.hash
-        builder.pre(:class => 'embed') do |pre|
-          pre << %{<a href="#" onclick="img=document.getElementById('#{id}'); img.style.display = (img.style.display == 'none' ? 'block' : 'none');">Screenshot</a>
-          <img id="#{id}" style="display: none" src="#{file}" />}
+        def set_scenario_color(status)
+          if status == :undefined
+            @builder.script do
+              @builder.text!("makeYellow('cucumber-header');") unless @header_red
+              @builder.text!("makeYellow('scenario_#{@scenario_number}');") unless @scenario_red
+            end 
+          end
+          if status == :failed
+            @builder.script do
+              @builder.text!("makeRed('cucumber-header');") unless @header_red
+              @header_red = true
+              @builder.text!("makeRed('scenario_#{@scenario_number}');") unless @scenario_red
+              @scenario_red = true
+            end
+          end
         end
-      end
 
-      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|
-            name << h(step_name).gsub(/&lt;span class=&quot;(.*?)&quot;&gt;/, '<span class="\1">').gsub(/&lt;\/span&gt;/, '</span>')
+        def get_step_count(features)
+          count = 0
+          features = features.instance_variable_get("@features")
+          features.each do |feature|
+            #get background steps
+            if feature.instance_variable_get("@background")
+              background = feature.instance_variable_get("@background").instance_variable_get("@steps").instance_variable_get("@steps")
+              count += background.size
+            end
+            #get scenarios
+            feature.instance_variable_get("@feature_elements").each do |scenario|
+              #get steps
+              steps = scenario.instance_variable_get("@steps").instance_variable_get("@steps")
+              count += steps.size
+
+              #get example table
+              examples = scenario.instance_variable_get("@examples_array")
+              unless examples.nil?
+                examples.each do |example|
+                  example_matrix = example.instance_variable_get("@outline_table").instance_variable_get("@cell_matrix")
+                  count += example_matrix.size
+                end
+              end
+
+              #get multiline step tables
+              steps.each do |step|
+                multi_arg = step.instance_variable_get("@multiline_arg")
+                next if multi_arg.nil?
+                matrix = multi_arg.instance_variable_get("@cell_matrix")
+                count += matrix.size unless matrix.nil?
+              end
+            end
           end
+          return count
         end
-      end
 
-      def build_cell(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'))
+        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|
+              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, 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_js_content
+          end
+        end
+
+        def inline_js_content
+          <<-EOF
+      function moveProgressBar(percentDone) {
+      document.getElementById("cucumber-header").style.width = percentDone +"%";
+      }
+      function makeRed(element_id) {
+      document.getElementById(element_id).style.background = '#C40D0D';
+      document.getElementById(element_id).style.color = '#FFFFFF';
+      }
+
+      function makeYellow(element_id) {
+      document.getElementById(element_id).style.background = '#FAF834';
+      document.getElementById(element_id).style.color = '#000000';
+      }
+      EOF
+        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}"] + exception.backtrace).join("\n")
+        end
+
+        def backtrace_line(line)
+          line.gsub(/^([^:]*\.(?:rb|feature|haml)):(\d*)/) do
+            if ENV['TM_PROJECT_DIRECTORY']
+              "<a href=\"txmt://open?url=file://#{File.expand_path($1)}&line=#{$2}\">#{$1}:#{$2}</a> "
+            else
+              line
+            end
+          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(@step_mother.scenarios.length, "scenario")
+          scenario_count = print_status_counts{|status| @step_mother.scenarios(status)}
+          string << scenario_count if scenario_count
+          string << "<br />"
+          string << dump_count(@step_mother.steps.length, "step")
+          step_count = print_status_counts{|status| @step_mother.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.to_s}" : 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)
+          OrderedXmlMarkup.new(:target => io, :indent => 0)
         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
+
+
+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
+
+  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
+      return snippet_for()
+      ["# Couldn't get snippet for #{error_line}", 1]
+    end
+  end
+
+  def lines_around(file, line)
+    if File.file?(file)
+      lines = File.open(file).read.split("\n")
+      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
+
+end