dwaite-cucumber 0.3.101

data/lib/cucumber/formatter/cucumber.sass

@@ -0,0 +1,139 @@
+# cucumber.css is generated from cucumber.sass
+# Regenerate with rake sass
+
+!step_left   = 5px solid
+!step_bottom = 1px solid
+
+!failed         = #FFC0CB
+!failed_dark    = #FF0000
+!failed_text    = #8B0000
+
+!passed         = #98FB98
+!passed_dark    = #00FF00
+!passed_text    = #001111
+
+!skipped        = #E0FFFF
+!skipped_dark   = #00FFFF
+!skipped_text   = #001111
+
+!pending        = #FFFF00
+!pending_dark   = #FF8000
+!pending_text   = #2A1B0A
+
+!undefined      = #FFFF00
+!undefined_dark = #FF8000
+!undefined_text = #2A1B0A
+
+.cucumber
+  :font-family "Lucida Grande", Helvetica, sans-serif
+  :font-size 0.7em
+  :background white
+  :padding 1em
+  
+  h1, h2, h3, h4, ol, li, pre, p
+    :font-size 1em
+    :padding 0px
+    :margin 0px
+
+  div.feature
+    :border 1px solid 
+    :padding 2px
+    :margin 4px
+
+    div.background, div.scenario, p
+      :padding 0em 0em 0em 1em
+      div.examples
+        :padding 0em 0em 0em 1em
+
+  .stats
+    :margin 2em
+
+  .summary
+    ul.features
+      li
+        :display inline
+
+  .backtrace
+    :margin-top 0
+    :margin-bottom 0
+    :margin-left 1em
+
+  a
+    :text-decoration none
+    :color inherit
+
+    &:hover
+      :text-decoration underline
+    &:visited
+      :font-weight normal
+
+    div.examples
+      :border 1px solid 
+      :padding 2px
+      :margin 4px
+
+  table
+    :border-collapse collapse
+    
+    td, th
+      :font-size 0.7em
+      :border 1px solid #AAAAAA
+    td.failed
+      :background #FFC0CB
+      :color #8B0000
+    td.passed
+      :background #98FB98
+      :color= !passed_text
+    td.skipped
+      :background= !skipped
+      :color= !skipped_text
+    td.pending
+      :background #FFFFE0
+      :color #111100
+    td.undefined
+      :background #FFFFE0
+      :color #111100
+
+  ol
+    :list-style none
+  
+    li
+      :margin 0em 0em 0em 1em
+      :padding 0em 0em 0em 0.2em
+      span.param
+        :font-weight bold
+    li.failed
+      :border-left= !step_left !failed_dark
+      :border-bottom= !step_bottom !failed_dark
+      :background= !failed
+      :color= !failed_text
+      span.param
+        :background !failed_dark
+    li.passed
+      :border-left= !step_left !passed_dark
+      :border-bottom= !step_bottom !passed_dark
+      :background= !passed
+      :color= !passed_text
+      span.param
+        :background= !passed_dark
+    li.skipped
+      :border-left= !step_left !skipped_dark
+      :border-bottom= !step_bottom !skipped_dark
+      :background= !skipped
+      :color= !skipped_text
+      span.param
+        :background= !skipped_dark
+    li.pending
+      :border-left= !step_left !pending_dark
+      :border-bottom= !step_bottom !pending_dark
+      :background= !pending
+      :color= !pending_text
+      span.param
+        :background= !pending_dark
+    li.undefined
+      :border-left= !step_left !undefined_dark
+      :border-bottom= !step_bottom !undefined_dark
+      :background= !undefined
+      :color= !undefined_text
+      span.param
+        :background= !undefined_dark

data/lib/cucumber/formatter/duration.rb

@@ -0,0 +1,13 @@
+module Cucumber
+  module Formatter
+    module Duration
+      # Helper method for formatters that need to
+      # format a duration in seconds to the UNIX
+      # <tt>time</tt> format.
+      def format_duration(seconds)
+        m, s = seconds.divmod(60)
+        "#{m}m#{'%.3f' % s}s" 
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/html.rb

@@ -0,0 +1,261 @@
+require 'cucumber/formatter/ordered_xml_markup'
+require 'cucumber/formatter/duration'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format html</tt>
+    class Html < Ast::Visitor
+      include ERB::Util # for the #h method
+      include Duration
+
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @options = options
+        @builder = create_builder(io)
+      end
+      
+      def create_builder(io)
+        OrderedXmlMarkup.new(:target => io, :indent => 0)
+      end
+      
+      def visit_features(features)
+        # <!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') do
+          @builder.head do
+            @builder.meta(:content => 'text/html;charset=utf-8')
+            @builder.title 'Cucumber'
+            inline_css
+          end
+          @builder.body do
+            @builder.div(:class => 'cucumber') do
+              super
+              @builder.div(format_duration(features.duration), :class => 'duration')
+            end
+          end
+        end
+      end
+
+      def visit_comment(comment)
+        @builder.pre(:class => 'comment') do
+          super
+        end
+      end
+
+      def visit_comment_line(comment_line)
+        @builder.text!(comment_line)
+        @builder.br
+      end
+
+      def visit_feature(feature)
+        @exceptions = []
+        @builder.div(:class => 'feature') do
+          super
+        end
+      end
+
+      def visit_tags(tags)
+        super
+        @tag_spacer = nil
+      end
+
+      def visit_tag_name(tag_name)
+        @builder.text!(@tag_spacer) if @tag_spacer
+        @tag_spacer = ' '
+        @builder.span("@#{tag_name}", :class => 'tag')
+      end
+
+      def visit_feature_name(name)
+        lines = name.split(/\r?\n/)
+        return if lines.empty?
+        @builder.h2 do |h2|
+          @builder.span(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 visit_background(background)
+        @builder.div(:class => 'background') do
+          @in_background = true
+          super
+          @in_background = nil
+        end
+      end
+
+      def visit_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')
+        end
+      end
+
+      def visit_feature_element(feature_element)
+        css_class = {
+          Ast::Scenario        => 'scenario',
+          Ast::ScenarioOutline => 'scenario outline'
+        }[feature_element.class]
+        @builder.div(:class => css_class) do
+          super
+        end
+        @open_step_list = true
+      end
+      
+      def visit_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')
+        end
+      end
+
+      def visit_outline_table(outline_table)
+        @outline_row = 0
+        @builder.table do
+          super(outline_table)
+        end
+        @outline_row = nil
+      end
+
+      def visit_examples(examples)
+        @builder.div(:class => 'examples') do
+          super(examples)
+        end
+      end
+
+      def visit_examples_name(keyword, name)
+        @builder.h4 do
+          @builder.span(keyword, :class => 'keyword')
+          @builder.text!(' ')
+          @builder.span(name, :class => 'val')
+        end
+      end
+
+      def visit_steps(steps)
+        @builder.ol do
+          super
+        end
+      end
+
+      def visit_step(step)
+        @step_id = step.dom_id
+        super
+      end
+
+      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        if exception
+          return if @exceptions.index(exception)
+          @exceptions << exception
+        end
+        return if status != :failed && @in_background ^ background
+        @status = status
+        @builder.li(:id => @step_id, :class => "step #{status}") do
+          super(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        end
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        @step_matches ||= []
+        background_in_scenario = background && !@listing_background
+        @skip_step = @step_matches.index(step_match) || background_in_scenario
+        @step_matches << step_match
+
+        unless @skip_step
+          build_step(keyword, step_match, status)
+        end
+      end
+
+      def visit_exception(exception, status)
+        @builder.pre(format_exception(exception), :class => status)
+      end
+
+      def visit_multiline_arg(multiline_arg)
+        return if @skip_step
+        if Ast::Table === multiline_arg
+          @builder.table do
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def visit_py_string(string)
+        @builder.pre(:class => 'val') do |pre|
+          @builder << string.gsub("\n", '&#x000A;')
+        end
+      end
+
+      def visit_table_row(table_row)
+        @row_id = table_row.dom_id
+        @col_index = 0
+        @builder.tr(:id => @row_id) do
+          super
+        end
+        if table_row.exception
+          @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
+      end
+
+      def visit_table_cell_value(value, status)
+        cell_type = @outline_row == 0 ? :th : :td
+        attributes = {:id => "#{@row_id}_#{@col_index}", :class => 'val'}
+        attributes[:class] += " #{status}" if status
+        build_cell(cell_type, value, attributes)
+        @col_index += 1
+      end
+      
+      def announce(announcement)
+        @builder.pre(announcement, :class => 'announcement')
+      end
+
+      protected
+      
+      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, value, attributes)
+      end
+
+      def inline_css
+        @builder.style(:type => 'text/css') do
+          @builder.text!(File.read(File.dirname(__FILE__) + '/cucumber.css'))
+        end
+      end
+
+      def format_exception(exception)
+        h((["#{exception.message} (#{exception.class})"] + exception.backtrace).join("\n"))
+      end
+      
+    end
+  end
+end

data/lib/cucumber/formatter/junit.rb

@@ -0,0 +1,121 @@
+require 'cucumber/formatter/ordered_xml_markup'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format junit</tt>
+    class Junit < Cucumber::Ast::Visitor
+
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        raise "You *must* specify --out DIR for the junit formatter" unless String === io && File.directory?(io)
+        @reportdir = io
+        @options = options
+      end
+
+      def visit_feature(feature)
+        @failures = @errors = @tests = 0
+        @builder = OrderedXmlMarkup.new( :indent => 2 )
+        @time = 0
+        super
+
+        @testsuite = OrderedXmlMarkup.new( :indent => 2 )
+        @testsuite.instruct!
+        @testsuite.testsuite(
+          :failures => @failures,
+          :errors => @errors,
+          :tests => @tests,
+          :time => "%.6f" % @time,
+        :name => @feature_name ) do
+          @testsuite << @builder.target!
+        end
+
+        basename = File.basename(feature.file)[0...-File.extname(feature.file).length]
+        feature_filename = File.join(@reportdir, "TEST-#{basename}.xml")
+        File.open(feature_filename, 'w') { |file| file.write(@testsuite.target!) }
+      end
+
+      def visit_background(name)
+        @in_background = true
+        super
+        @in_background = false
+      end
+
+      def visit_feature_name(name)
+        lines = name.split(/\r?\n/)
+        @feature_name = lines[0].sub(/Feature\:/, '').strip
+      end
+
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+        scenario_name = name.strip.delete(".\r\n")
+        scenario_name = "Unnamed scenario" if name.blank?
+        @scenario = scenario_name
+        @outline = keyword.include?('Scenario Outline')
+        @output = "Scenario#{ " outline" if @outline}: #{@scenario}\n\n"
+      end
+
+      def visit_steps(steps)
+        return if @in_background
+        start = Time.now
+        super
+        duration = Time.now - start
+        unless @outline
+          if steps.failed?
+            steps.each { |step| @output += "#{step.keyword} #{step.name}\n" }
+            @output += "\nMessage:\n"
+          end
+          build_testcase(duration, steps.status, steps.exception)
+        end
+      end
+
+      def visit_outline_table(outline_table)
+        @header_row = true
+        super(outline_table)
+      end
+
+      def visit_table_row(table_row)
+        if @outline
+          start = Time.now
+          super(table_row)
+          duration = Time.now - start
+          unless @header_row
+            name_suffix = " (outline example : #{table_row.name})"
+            if table_row.failed?
+              @output += "Example row: #{table_row.name}\n"
+              @output += "\nMessage:\n"
+            end
+            build_testcase(duration, table_row.status, table_row.exception,  name_suffix)
+          end
+        else
+          super(table_row)
+        end
+        @header_row = false
+      end
+
+      private
+
+        def build_testcase(duration, status, exception = nil, suffix = "")
+          @time += duration
+          classname = "#{@feature_name}.#{@scenario}"
+          name = "#{@scenario}#{suffix}"
+          failed = (status == :failed || (status == :pending && @options[:strict]))
+          #puts "FAILED:!!#{failed}"
+          if status == :passed || failed
+            @builder.testcase(:classname => classname, :name => name, :time => "%.6f" % duration) do
+              if failed
+                @builder.failure(:message => "#{status.to_s} #{name}", :type => status.to_s) do
+                  @builder.text! @output
+                  @builder.text!(format_exception(exception)) if exception
+                end
+                @failures += 1
+              end
+            end
+            @tests += 1
+          end
+        end
+
+        def format_exception(exception)
+          (["#{exception.message} (#{exception.class})"] + exception.backtrace).join("\n")
+        end
+    end
+  end
+end

data/lib/cucumber/formatter/ordered_xml_markup.rb

@@ -0,0 +1,24 @@
+begin
+  require 'builder'
+rescue LoadError
+  gem 'builder'
+  require 'builder'
+end
+
+module Cucumber
+  module Formatter
+    # Emits attributes ordered alphabetically, so that we can predicatbly test output.
+    class OrderedXmlMarkup < Builder::XmlMarkup #:nodoc:
+      def _insert_attributes(attrs, order=[])
+        return if attrs.nil?
+        keys = attrs.keys.map{|k| k.to_s}
+        keys.sort!
+        keys.reverse! if (attrs.keys - [:version, :encoding] == []) #HACK to ensure the 'version' attribute is first in xml declaration.
+        keys.each do |k|
+          v = attrs[k.to_sym] || attrs[k]
+          @target << %{ #{k}="#{_attr_value(v)}"} if v
+        end
+      end
+    end
+  end
+end