lucid 0.0.4 → 0.0.5

data/lib/lucid/formatter/console.rb

@@ -0,0 +1,218 @@
+require 'lucid/formatter/ansicolor'
+require 'lucid/formatter/duration'
+require 'lucid/formatter/summary'
+
+module Lucid
+  module Formatter
+
+    # This module contains helper methods that are used by formatters that
+    # print output to the terminal.
+    #
+    # FORMAT is a hash of Proc objects, keyed by step-definition types, e.g.
+    # "FORMAT[:passed]".  The Proc is called for each line of the step's
+    # output.
+    #
+    # format_step calls format_string, format_string calls format_for to obtain
+    # the formatting Proc.
+    #
+    # Example:
+    #
+    # The ANSI color console formatter defines a map of step-type to output
+    # color (e.g. "passed" to "green"), then builds methods named for the
+    # step-types (e.g. "def passed"), which themselves wrap the corresponding
+    # color-named methods provided by Term::ANSIColor (e.g. "def red").
+    #
+    # During output, each line is processed by passing it to the formatter Proc
+    # which returns the formatted (e.g. colored) string.
+
+    module Console
+      extend ANSIColor
+      include Duration
+      include Summary
+
+      def format_step(keyword, step_match, status, source_indent)
+        comment = if source_indent
+          c = (' # ' + step_match.file_colon_line).indent(source_indent)
+          format_string(c, :comment)
+        else
+          ''
+        end
+
+        format = format_for(status, :param)
+        line = keyword + step_match.format_args(format) + comment
+        format_string(line, status)
+      end
+
+      def format_string(o, status)
+        fmt = format_for(status)
+        o.to_s.split("\n").map do |line|
+          if Proc === fmt
+            fmt.call(line)
+          else
+            fmt % line
+          end
+        end.join("\n")
+      end
+
+      def print_steps(status)
+        print_elements(runtime.steps(status), status, 'steps')
+      end
+
+      def print_elements(elements, status, kind)
+        if elements.any?
+          @io.puts(format_string("(::) #{status} #{kind} (::)", status))
+          @io.puts
+          @io.flush
+        end
+
+        elements.each_with_index do |element, i|
+          if status == :failed
+            print_exception(element.exception, status, 0)
+          else
+            @io.puts(format_string(element.backtrace_line, status))
+          end
+          @io.puts
+          @io.flush
+        end
+      end
+
+      def print_stats(features, options)
+        @failures = runtime.scenarios(:failed).select { |s| s.is_a?(Lucid::AST::Scenario) || s.is_a?(Lucid::AST::OutlineTable::ExampleRow) }
+        @failures.collect! { |s| (s.is_a?(Lucid::AST::OutlineTable::ExampleRow)) ? s.scenario_outline : s }
+
+        if !@failures.empty?
+          @io.puts format_string("Failing Scenarios:", :failed)
+          @failures.each do |failure|
+            profiles_string = options.custom_profiles.empty? ? '' : (options.custom_profiles.map{|profile| "-p #{profile}" }).join(' ') + ' '
+            source = options[:source] ? format_string(" # Scenario: " + failure.name, :comment) : ''
+            @io.puts format_string("Lucid #{profiles_string}" + failure.file_colon_line, :failed) + source
+          end
+          @io.puts
+        end
+
+        @io.puts scenario_summary(runtime) {|status_count, status| format_string(status_count, status)}
+        @io.puts step_summary(runtime) {|status_count, status| format_string(status_count, status)}
+
+        @io.puts(format_duration(features.duration)) if features && features.duration
+
+        @io.flush
+      end
+
+      def print_exception(e, status, indent)
+        message = "#{e.message} (#{e.class})"
+        if ENV['LUCID_TRUNCATE_OUTPUT']
+          message = linebreaks(message, ENV['LUCID_TRUNCATE_OUTPUT'].to_i)
+        end
+
+        string = "#{message}\n#{e.backtrace.join("\n")}".indent(indent)
+        @io.puts(format_string(string, status))
+      end
+
+      # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/10655
+      def linebreaks(s, max)
+        s.gsub(/.{1,#{max}}(?:\s|\Z)/){($& + 5.chr).gsub(/\n\005/,"\n").gsub(/\005/,"\n")}.rstrip
+      end
+
+      def print_matchers(options)
+        return unless options[:matchers]
+        undefined = runtime.steps(:undefined)
+        return if undefined.empty?
+
+        unknown_programming_language = runtime.unknown_programming_language?
+        matchers = undefined.map do |step|
+          step_name = Undefined === step.exception ? step.exception.step_name : step.name
+          step_multiline_class = step.multiline_arg ? step.multiline_arg.class : nil
+          matcher = @runtime.matcher_text(step.actual_keyword, step_name, step_multiline_class)
+          matcher
+        end.compact.uniq
+
+        text = "\nYou can implement test definitions for undefined test steps with these matchers:\n\n"
+        text += matchers.join("\n\n")
+        @io.puts format_string(text, :undefined)
+
+        if unknown_programming_language
+          @io.puts format_string("\nIf you want matchers in a different programming language," +
+                                 "\njust make sure a file with the appropriate file extension" +
+                                 "\nexists where Lucid looks for test definitions.", :failed)
+        end
+
+        @io.puts
+        @io.flush
+      end
+
+      def print_passing_wip(options)
+        return unless options[:wip]
+        passed = runtime.scenarios(:passed)
+        if passed.any?
+          @io.puts format_string("\nThe --wip switch was used, so nothing was expected to pass. These scenarios passed:", :failed)
+          print_elements(passed, :passed, "scenarios")
+        else
+          @io.puts format_string("\nThe --wip switch was used, so any failures were expected. All is good.\n", :passed)
+        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))
+        @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?
+        profiles = @options[:profiles]
+        profiles_sentence = ''
+        profiles_sentence = profiles.size == 1 ? profiles.first :
+          "#{profiles[0...-1].join(', ')} and #{profiles.last}"
+
+        @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 }
+
+    def format_for(*keys)
+      key = keys.join('_').to_sym
+      fmt = FORMATS[key]
+      raise "No format for #{key.inspect}: #{FORMATS.inspect}" if fmt.nil?
+      fmt
+    end
+
+    end
+  end
+end

data/lib/lucid/formatter/debug.rb

@@ -0,0 +1,33 @@
+require 'lucid/formatter/progress'
+require 'lucid/step_definition_light'
+
+module Lucid
+  module Formatter
+    class Debug
+      def initialize(runtime, io, options)
+        @io = io
+        @indent = 0
+      end
+
+      def respond_to?(*args)
+        true
+      end
+
+      def method_missing(name, *args)
+        @indent -= 2 if name.to_s =~ /^after/
+        print(name)
+        @indent += 2 if name.to_s =~ /^before/
+      end
+
+    private
+
+      def print(text)
+        @io.puts "#{indent}#{text}"
+      end
+
+      def indent
+        (' ' * @indent)
+      end
+    end
+  end
+end

data/lib/lucid/formatter/duration.rb

@@ -0,0 +1,11 @@
+module Lucid
+  module Formatter
+    module Duration
+      # Format a duration in seconds in the Unix time format.
+      def format_duration(seconds)
+        m, s = seconds.divmod(60)
+        "#{m}m#{'%.3f' % s}s"
+      end
+    end
+  end
+end

data/lib/lucid/formatter/gherkin_formatter_adapter.rb

@@ -0,0 +1,94 @@
+require 'lucid/formatter/io'
+require 'gherkin/formatter/argument'
+
+module Lucid
+  module Formatter
+    # Adapts Lucid formatter events to Gherkin formatter events
+    # This class will disappear when Lucid is based on Gherkin's model.
+    class GherkinFormatterAdapter
+      def initialize(gherkin_formatter, print_empty_match)
+        @gf = gherkin_formatter
+        @print_empty_match = print_empty_match
+      end
+
+      def before_feature(feature)
+        @gf.uri(feature.file)
+        @gf.feature(feature.gherkin_statement)
+      end
+
+      def before_background(background)
+        @outline = false
+        @gf.background(background.gherkin_statement)
+      end
+
+      def before_feature_element(feature_element)
+        case(feature_element)
+        when AST::Scenario
+          @outline = false
+          @gf.scenario(feature_element.gherkin_statement)
+        when AST::ScenarioOutline
+          @outline = true
+          @gf.scenario_outline(feature_element.gherkin_statement)
+        else
+          raise "Bad type: #{feature_element.class}"
+        end
+      end
+
+      def before_step(step)
+        @gf.step(step.gherkin_statement)
+        if @print_empty_match
+          if(@outline)
+            match = Gherkin::Formatter::Model::Match.new(step.gherkin_statement.outline_args, nil)
+          else
+            match = Gherkin::Formatter::Model::Match.new([], nil)
+          end
+          @gf.match(match)
+        end
+        @step_time = Time.now
+      end
+
+      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
+        arguments = step_match.step_arguments.map{|a| Gherkin::Formatter::Argument.new(a.offset, a.val)}
+        location = step_match.file_colon_line
+        match = Gherkin::Formatter::Model::Match.new(arguments, location)
+        if @print_empty_match
+          # Trick the formatter to believe that's what was printed previously so we get arg highlights on #result
+          @gf.instance_variable_set('@match', match)
+        else
+          @gf.match(match)
+        end
+
+        error_message = exception ? "#{exception.message} (#{exception.class})\n#{exception.backtrace.join("\n")}" : nil
+        unless @outline
+          @gf.result(Gherkin::Formatter::Model::Result.new(status, nil, error_message))
+        end
+      end
+
+      def before_examples(examples)
+        @gf.examples(examples.gherkin_statement)
+      end
+
+      #used for capturing duration
+      def after_step(step)
+        step_finish = (Time.now - @step_time)
+        @gf.append_duration(step_finish)
+      end
+
+      def after_feature(feature)
+        @gf.eof
+      end
+
+      def after_features(features)
+        @gf.done
+      end
+
+      def embed(file, mime_type, label)
+        data = File.open(file, 'rb') { |f| f.read }
+        if defined?(JRUBY_VERSION)
+          data = data.to_java_bytes
+        end
+        @gf.embedding(mime_type, data)
+      end
+    end
+  end
+end

data/lib/lucid/formatter/gpretty.rb

@@ -0,0 +1,24 @@
+require 'lucid/formatter/gherkin_formatter_adapter'
+require 'lucid/formatter/io'
+require 'gherkin/formatter/argument'
+require 'gherkin/formatter/pretty_formatter'
+
+module Lucid
+  module Formatter
+    # The formatter used for <tt>--format gpretty</tt>
+    class Gpretty < GherkinFormatterAdapter
+      include Io
+
+      def initialize(runtime, io, options)
+        @io = ensure_io(io, "json")
+        super(Gherkin::Formatter::PrettyFormatter.new(@io, false), true)
+      end
+
+      def after_feature(feature)
+        super
+        @io.puts
+      end
+    end
+  end
+end
+

data/lib/lucid/formatter/html.rb

@@ -0,0 +1,610 @@
+require 'erb'
+require 'lucid/formatter/ordered_xml_markup'
+require 'lucid/formatter/duration'
+require 'lucid/formatter/io'
+
+module Lucid
+  module Formatter
+    class Html
+      include ERB::Util
+      include Duration
+      include Io
+
+      def initialize(runtime, path_or_io, options)
+        @io = ensure_io(path_or_io, "html")
+        @runtime = runtime
+        @options = options
+        @buffer = {}
+        @builder = create_builder(@io)
+        @feature_number = 0
+        @scenario_number = 0
+        @step_number = 0
+        @header_red = nil
+        @delayed_messages = []
+        @img_id = 0
+      end
+
+      def embed(src, mime_type, label)
+        case(mime_type)
+        when /^image\/(png|gif|jpg|jpeg)/
+          embed_image(src, label)
+        end
+      end
+
+      def embed_image(src, label)
+        id = "img_#{@img_id}"
+        @img_id += 1
+        @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
+      end
+
+      def before_features(features)
+        @step_count = features.step_count
+
+        @builder.declare!(:DOCTYPE, :html)
+
+        @builder << '<html>'
+        @builder.head do
+          @builder.meta(:charset => 'utf-8')
+          @builder.title 'Lucid'
+          inline_css
+          inline_js
+        end
+        @builder << '<body>'
+        @builder << "<!-- Step count #{@step_count}-->"
+        @builder << '<div class="lucid">'
+
+        @builder.div(:id => 'lucid-header') do
+          @builder.div(:id => 'label') do
+            @builder.h1('Lucid 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
+      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_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::Scenario        => 'scenario',
+          AST::ScenarioOutline => 'scenario outline'
+        }[feature_element.class]
+        @builder << "<div class='#{css_class}'>"
+      end
+
+      def after_feature_element(feature_element)
+        @builder << '</div>'
+        @open_step_list = true
+      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
+        @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
+        @builder << '<table>'
+      end
+
+      def after_outline_table(outline_table)
+        @builder << '</table>'
+        @outline_row = nil
+      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 before_steps(steps)
+        @builder << '<ol>'
+      end
+
+      def after_steps(steps)
+        @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, 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
+        if status == :undefined
+          keyword = @step.actual_keyword if @step.respond_to?(:actual_keyword)
+          step_multiline_class = @step.multiline_arg ? @step.multiline_arg.class : nil
+          @builder.pre do |pre|
+            pre << @runtime.matcher_text(keyword,step_match.instance_variable_get("@name") || '',step_multiline_class)
+          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)
+        build_exception_detail(exception)
+      end
+
+      def extra_failure_content(file_colon_line)
+        @matcher_extractor ||= MatcherExtractor.new
+        "<pre class=\"ruby\"><code>#{@matcher_extractor.matcher(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)
+        return if @hide_this_step || @skip_step
+        if AST::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? ::Lucid::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)
+        @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
+
+      protected
+
+      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\/(lucid|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('lucid-header');") unless @header_red
+          @header_red = true
+          @builder.text!("makeRed('scenario_#{@scenario_number}');") unless @scenario_red
+          @scenario_red = true
+        end
+      end
+
+      def set_scenario_color_pending
+        @builder.script do
+          @builder.text!("makeYellow('lucid-header');") unless @header_red
+          @builder.text!("makeYellow('scenario_#{@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 inline_css
+        @builder.style(:type => 'text/css') do
+          @builder << File.read(File.dirname(__FILE__) + '/lucid.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) {
+    $("lucid-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>"
+      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(/\A([^:]*\.(?:rb|feature|haml)):(\d*).*\z/) 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(@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.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
+
+      class MatcherExtractor #: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 matcher(error)
+          raw_code, line = matcher_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 matcher_for(error_line)
+          if error_line =~ /(.*):(\d+)/
+            file = $1
+            line = $2.to_i
+            [lines_around(file, line), line]
+          else
+            ["# Could not get matcher 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
+            "# Lucid was unable to get a matcher 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
+    end
+  end
+end