kbaum-cucumber 0.4.5.pre

data/lib/cucumber/formatter/io.rb

@@ -0,0 +1,33 @@
+require 'cucumber/formatter/color_io'
+
+module Cucumber
+  module Formatter
+    module Io
+      def ensure_io(path_or_io, name)
+        return nil if path_or_io.nil?
+        return path_or_io if ColorIO === path_or_io || path_or_io.respond_to?(:write)
+        file = File.open(path_or_io, Cucumber.file_mode('w'))
+        at_exit do
+          unless file.closed?
+            file.flush
+            file.close
+          end
+        end
+        file
+      end
+
+      def ensure_file(path, name)
+        raise "You *must* specify --out FILE for the #{name} formatter" unless String === path
+        raise "I can't write #{name} to a directory - it has to be a file" if File.directory?(path)
+        ensure_io(path, name)
+      end
+
+      def ensure_dir(path, name)
+        raise "You *must* specify --out DIR for the #{name} formatter" unless String === path
+        raise "I can't write #{name} reports to a file - it has to be a directory" if File.file?(path)
+        FileUtils.mkdir_p(path) unless File.directory?(path)
+        path
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/junit.rb

@@ -0,0 +1,149 @@
+require 'cucumber/formatter/ordered_xml_markup'
+require 'cucumber/formatter/io'
+require 'fileutils'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format junit</tt>
+    class Junit
+      include Io
+      
+      class UnNamedFeatureError < StandardError
+        def initialize(feature_file)
+          super("The feature in '#{feature_file}' does not have a name. The JUnit XML format requires a name for the testsuite element.")
+        end
+      end
+      
+      def initialize(step_mother, io, options)
+        @reportdir = ensure_dir(io, "junit")
+        @options = options
+      end
+
+      def before_feature(feature)
+        @current_feature = feature
+        @failures = @errors = @tests = 0
+        @builder = OrderedXmlMarkup.new( :indent => 2 )
+        @time = 0
+      end
+      
+      def after_feature(feature)
+        @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
+
+        write_file(feature_result_filename(feature.file), @testsuite.target!)
+      end
+
+      def before_background(*args)
+        @in_background = true
+      end
+      
+      def after_background(*args)
+        @in_background = false
+      end
+
+      def feature_name(name)
+        raise UnNamedFeatureError.new(@current_feature.file) if name.empty?
+        lines = name.split(/\r?\n/)
+        @feature_name = lines[0].sub(/Feature\:/, '').strip
+      end
+
+      def 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
+        description = "Scenario"
+        description << " outline" if keyword.include?('Scenario Outline')
+        @output = "#{description}: #{@scenario}\n\n"
+      end
+
+      def before_steps(steps)
+        @steps_start = Time.now
+      end
+      
+      def after_steps(steps)
+        return if @in_background || @in_examples
+        
+        duration = Time.now - @steps_start
+        if steps.failed?
+          steps.each { |step| @output += "#{step.keyword} #{step.name}\n" }
+          @output += "\nMessage:\n"
+        end
+        build_testcase(duration, steps.status, steps.exception)
+      end
+      
+      def before_examples(*args)
+        @header_row = true
+        @in_examples = true
+      end
+      
+      def after_examples(*args)
+        @in_examples = false
+      end
+
+      def before_table_row(table_row)
+        return unless @in_examples
+
+        @table_start = Time.now
+      end
+
+      def after_table_row(table_row)
+        return unless @in_examples
+        duration = Time.now - @table_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
+        
+        @header_row = false if @header_row
+      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
+      
+      def feature_result_filename(feature_file)
+        ext_length = File.extname(feature_file).length
+        basename = File.basename(feature_file)[0...-ext_length]
+        File.join(@reportdir, "TEST-#{basename}.xml")
+      end
+      
+      def write_file(feature_filename, data)
+        File.open(feature_filename, 'w') { |file| file.write(data) }
+      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

data/lib/cucumber/formatter/pdf.rb

@@ -0,0 +1,234 @@
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/io'
+require 'fileutils'
+require 'prawn'
+require "prawn/layout"
+require "prawn/format"
+
+module Cucumber
+  module Formatter
+
+    BLACK = '000000'
+    GREY = '999999'
+
+    class Pdf
+      include FileUtils
+      include Console
+      include Io
+      attr_writer :indent
+
+      def initialize(step_mother, path_or_io, options)
+        @step_mother = step_mother
+        @file = ensure_file(path_or_io, "pdf")
+
+        if(options[:dry_run])
+          @status_colors = { :passed => BLACK, :skipped => BLACK, :undefined => BLACK, :failed => BLACK}
+        else
+          @status_colors = { :passed => '055902', :skipped => GREY, :undefined => 'F27405', :failed => '730202'}
+        end
+
+        @pdf = Prawn::Document.new
+        @scrap = Prawn::Document.new
+        @doc = @scrap
+        @options = options
+        @exceptions = []
+        @indent = 0
+        @buffer = []
+        load_cover_page_image
+        @pdf.text "\n\n\nCucumber features", :align => :center, :size => 32
+        @pdf.text "Generated: #{Time.now.strftime("%Y-%m-%d %H:%M")}", :size => 10, :at => [0, 24]
+        @pdf.text "Command: <code>cucumber #{ARGV.join(" ")}</code>", :size => 10, :at => [0,10]
+        unless options[:dry_run]
+          @pdf.bounding_box [450,100] , :width => 100 do  
+            @pdf.text 'Legend', :size => 10
+            @status_colors.each do |k,v|
+              @pdf.fill_color v
+              @pdf.text k.to_s, :size => 10
+              @pdf.fill_color BLACK
+            end
+          end
+        end
+      end
+
+      def load_cover_page_image()
+        if (!load_image("features/support/logo.png"))
+          load_image("features/support/logo.jpg")
+        end
+      end
+
+      def load_image(image_path)
+        begin
+          @pdf.image open(image_path, "rb"), :position => :center, :width => 500
+          true
+        rescue Errno::ENOENT
+          false
+        end
+      end
+
+      def after_features(features)
+        @pdf.render_file(@file.path)
+        puts "\ndone"
+      end
+
+      def feature_name(name)
+        @pdf.start_new_page
+        name["Feature:"] = "" if name["Feature:"]
+        names = name.split("\n")
+        @pdf.fill_color GREY
+        @pdf.text('Feature', :align => :center)
+        @pdf.fill_color BLACK
+        names.each_with_index do |nameline, i|
+          case i
+          when 0
+            @pdf.text(nameline.strip, :size => 30, :align => :center )
+            @pdf.text("\n")
+          else
+            @pdf.text(nameline.strip, :size => 12)
+          end
+        end
+        @pdf.move_down(30)
+      end
+
+      def before_feature_element(feature_element)
+        record_tag_occurrences(feature_element, @options)
+      end
+      
+      def after_feature_element(feature_element)
+        flush
+      end
+
+      def after_feature(feature)
+        flush
+      end
+
+      def feature_element_name(keyword, name)
+        names = name.empty? ? [name] : name.split("\n")
+        print "."
+        STDOUT.flush
+
+        keep_with do
+          @doc.move_down(20)
+          @doc.fill_color GREY
+          @doc.text("#{keyword}", :size => 8)
+          @doc.fill_color BLACK
+          @doc.text("#{names[0]}", :size => 16)
+          names[1..-1].each { |s| @doc.text(s, :size => 12) }
+          @doc.text("\n")
+        end
+      end
+
+      def step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        @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
+      end
+
+      def step_name(keyword, step_match, status, source_indent, background)
+        return if @hide_this_step
+        line = "<b>#{keyword}</b> #{step_match.format_args("%s").gsub('<', '&lt;').gsub('>', '&gt;')}"
+        colorize(line, status)
+      end
+
+      def before_background(background)
+        @in_background = true
+      end
+
+      def after_background(background)
+        @in_background = nil
+      end
+
+      def before_multiline_arg(table)
+        return if @hide_this_step
+        if(table.kind_of? Cucumber::Ast::Table)
+          keep_with do
+            @doc.table(table.rows << table.headers , :position => :center, :row_colors => ['ffffff', 'f0f0f0'])
+          end
+        end
+      end
+
+      #using row_color hack to highlight each row correctly
+      def before_outline_table(table)
+        return if @hide_this_step
+        row_colors = table.example_rows.map { |r| @status_colors[r.status] unless r.status == :skipped}
+        keep_with do
+          @doc.table(table.rows, :headers => table.headers, :position => :center, :row_colors => row_colors)
+        end
+      end
+
+      def before_py_string(string)
+        return if @hide_this_step
+        s = %{"""\n#{string}\n"""}.indent(10)
+        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}
+        s.each do |line|
+          line.gsub!('<', '&lt;')
+          line.gsub!('>', '&gt;')
+          keep_with { @doc.text line, :size => 8 }
+        end
+      end
+
+      def tag_name(tag_name)
+        return if @hide_this_step
+        tag = format_string(tag_name, :tag).indent(@indent)
+        # TODO should we render tags at all? skipped for now. difficult to place due to page breaks
+      end
+
+      def background_name(keyword, name, file_colon_line, source_indent)
+        feature_element_name(keyword, name)
+      end
+
+      def examples_name(keyword, name)
+        feature_element_name(keyword, name)
+      end
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        feature_element_name(keyword, name)
+      end
+      
+      private
+      
+      def colorize(text, status)
+        keep_with do
+          @doc.fill_color(@status_colors[status] || BLACK)
+          @doc.text(text)
+          @doc.fill_color(BLACK)
+        end
+      end
+      
+      def keep_with(&block)
+        @buffer << block
+      end
+
+      def render(doc)
+        @doc = doc
+        @buffer.each do |proc|
+          proc.call
+        end
+      end
+
+      # This method does a 'test' rendering on a blank page, to see the rendered height of the buffer
+      # if that too high for the space left on the age in the real document, we do a page break.
+      # This obviously doesn't work if a scenario is longer than a whole page (God forbid)
+      def flush
+        @scrap.start_new_page
+        oldy = @scrap.y
+        render @scrap
+        height = (oldy - @scrap.y) + 36 # whops magic number
+        if ((@pdf.y - height) < @pdf.bounds.bottom)
+          @pdf.start_new_page
+        end
+        render @pdf
+        @pdf.move_down(20)
+        @buffer = []
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/pretty.rb

@@ -0,0 +1,237 @@
+require 'cucumber/formatter/console'
+require 'cucumber/formatter/io'
+require 'fileutils'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format pretty</tt> (the default formatter).
+    #
+    # This formatter prints features to plain text - exactly how they were parsed,
+    # just prettier. That means with proper indentation and alignment of table columns.
+    #
+    # If the output is STDOUT (and not a file), there are bright colours to watch too.
+    #
+    class Pretty
+      include FileUtils
+      include Console
+      include Io
+      attr_writer :indent
+      attr_reader :step_mother
+
+      def initialize(step_mother, path_or_io, options)
+        @step_mother, @io, @options = step_mother, ensure_io(path_or_io, "pretty"), options
+        @exceptions = []
+        @indent = 0
+        @prefixes = options[:prefixes] || {}
+        @delayed_announcements = []
+      end
+
+      def after_features(features)
+        print_summary(features) unless @options[:autoformat]
+      end
+
+      def before_feature(feature)
+        @exceptions = []
+        @indent = 0
+        if @options[:autoformat]
+          file = File.join(@options[:autoformat], feature.file)
+          dir = File.dirname(file)
+          mkdir_p(dir) unless File.directory?(dir)
+          @io = ensure_file(file, "pretty")
+        end
+      end
+      
+      def comment_line(comment_line)
+        @io.puts(comment_line.indent(@indent))
+        @io.flush
+      end
+
+      def after_tags(tags)
+        if @indent == 1
+          @io.puts
+          @io.flush
+        end
+      end
+
+      def tag_name(tag_name)
+        tag = format_string(tag_name, :tag).indent(@indent)
+        @io.print(tag)
+        @io.flush
+        @indent = 1
+      end
+
+      def feature_name(name)
+        @io.puts(name)
+        @io.puts
+        @io.flush
+      end
+
+      def before_feature_element(feature_element)
+        record_tag_occurrences(feature_element, @options)
+        @indent = 2
+        @scenario_indent = 2
+      end
+      
+      def after_feature_element(feature_element)
+        @io.puts
+        @io.flush
+      end
+
+      def before_background(background)
+        @indent = 2
+        @scenario_indent = 2
+        @in_background = true
+      end
+
+      def after_background(background)
+        @in_background = nil
+        @io.puts
+        @io.flush
+      end
+
+      def background_name(keyword, name, file_colon_line, source_indent)        
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def before_examples_array(examples_array)
+        @indent = 4
+        @io.puts
+        @visiting_first_example_name = true
+      end
+      
+      def examples_name(keyword, name)
+        puts unless @visiting_first_example_name
+        @visiting_first_example_name = false
+        names = name.strip.empty? ? [name.strip] : name.split("\n")
+        @io.puts("    #{keyword} #{names[0]}")
+        names[1..-1].each {|s| @io.puts "      #{s}" } unless names.empty?
+        @io.flush
+        @indent = 6
+        @scenario_indent = 6
+      end
+      
+      def before_outline_table(outline_table)
+        @table = outline_table
+      end
+
+      def after_outline_table(outline_table)
+        @table = nil
+        @indent = 4
+      end
+      
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        print_feature_element_name keyword, name, file_colon_line, source_indent
+      end
+
+      def before_step(step)
+        @current_step = step
+        @indent = 6
+      end
+
+      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        @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
+      end
+
+      def step_name(keyword, step_match, status, source_indent, background)
+        return if @hide_this_step
+        source_indent = nil unless @options[:source]
+        name_to_report = format_step(keyword, step_match, status, source_indent)
+        @io.puts(name_to_report.indent(@scenario_indent + 2))
+        print_announcements
+      end
+
+      def py_string(string)
+        return if @hide_this_step
+        s = %{"""\n#{string}\n"""}.indent(@indent)
+        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
+        @io.puts(format_string(s, @current_step.status))
+        @io.flush
+      end
+
+      def exception(exception, status)
+        return if @hide_this_step
+        print_exception(exception, status, @indent)
+        @io.flush
+      end
+
+      def before_multiline_arg(multiline_arg)
+        return if @options[:no_multiline] || @hide_this_step
+        @table = multiline_arg
+      end
+      
+      def after_multiline_arg(multiline_arg)
+        @table = nil
+      end
+
+      def before_table_row(table_row)
+        return if !@table || @hide_this_step
+        @col_index = 0
+        @io.print '  |'.indent(@indent-2)
+      end
+
+      def after_table_row(table_row)
+        return if !@table || @hide_this_step
+        print_table_row_announcements
+        @io.puts
+        if table_row.exception && !@exceptions.include?(table_row.exception)
+          print_exception(table_row.exception, table_row.status, @indent)
+        end
+      end
+
+      def after_table_cell(cell)
+        return unless @table
+        @col_index += 1
+      end
+
+      def table_cell_value(value, status)
+        return if !@table || @hide_this_step
+        status ||= @status || :passed
+        width = @table.col_width(@col_index)
+        cell_text = value.to_s || ''
+        padded = cell_text + (' ' * (width - cell_text.jlength))
+        prefix = cell_prefix(status)
+        @io.print(' ' + format_string("#{prefix}#{padded}", status) + ::Term::ANSIColor.reset(" |"))
+        @io.flush
+      end
+
+      private
+      
+      def print_feature_element_name(keyword, name, file_colon_line, source_indent)
+        @io.puts if @scenario_indent == 6
+        names = name.empty? ? [name] : name.split("\n")
+        line = "#{keyword} #{names[0]}".indent(@scenario_indent)
+        @io.print(line)
+        if @options[:source]
+          line_comment = " # #{file_colon_line}".indent(source_indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+        names[1..-1].each {|s| @io.puts "    #{s}"}
+        @io.flush        
+      end
+
+      def cell_prefix(status)
+        @prefixes[status]
+      end
+
+      def print_summary(features)
+        print_stats(features)
+        print_snippets(@options)
+        print_passing_wip(@options)
+        print_tag_limit_warnings(@options)
+      end
+    end
+  end
+end