dwaite-cucumber 0.3.101

data/lib/cucumber/formatter/pdf.rb

@@ -0,0 +1,217 @@
+require 'cucumber/formatter/console'
+require 'fileutils'
+require 'prawn'
+require "prawn/layout"
+require "prawn/format"
+
+module Cucumber
+  module Formatter
+
+    BLACK = '000000'
+    GREY = '999999'
+
+    class Pdf < Ast::Visitor
+      include FileUtils
+      include Console
+      attr_writer :indent
+
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        raise "You *must* specify --out FILE for the pdf formatter" unless File === io
+
+        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
+        @io = io
+        @options = options
+        @exceptions = []
+        @indent = 0
+        @buffer = []
+        puts "writing to #{io.path}"
+        begin
+          @pdf.image open("features/support/logo.png"), :position => :center, :width => 500
+        rescue
+        end
+        @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 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
+
+      # regular visitor entries
+      def visit_features(features)
+        super
+        @pdf.render_file(@io.path)
+        puts "\ndone"
+      end
+
+      def visit_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 visit_feature_element(feature_element)
+        record_tag_occurrences(feature_element, @options)
+        super
+        flush
+      end
+
+      def visit_feature(feature)
+        super
+        flush
+      end
+
+      def visit_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 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
+        super
+      end
+
+      def colorize(text, status)
+        keep_with do
+          @doc.fill_color(@status_colors[status] || BLACK)
+          @doc.text(text)
+          @doc.fill_color(BLACK)
+        end
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        line = "<b>#{keyword}</b> #{step_match.format_args("%s").gsub('<', '&lt;').gsub('>', '&gt;')}"
+        colorize(line, status)
+      end
+
+      def visit_background(background)
+        @in_background = true
+        super
+        @in_background = nil
+      end
+
+      def visit_multiline_arg(table)
+        if(table.kind_of? Cucumber::Ast::Table)
+          keep_with do
+            @doc.table(table.rows << table.headers , :position => :center, :row_colors => ['ffffff', 'f0f0f0'])
+          end
+        end
+        super
+      end
+
+      #using row_color hack to highlight each row correctly
+      def visit_outline_table(table)
+        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 visit_py_string(string)
+        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 visit_comment(comment)
+        comment.accept(self)
+      end
+
+      def visit_comment_line(comment_line)
+      end
+
+      def visit_tag_name(tag_name)
+        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 visit_background_name(keyword, name, file_colon_line, source_indent)
+        visit_feature_element_name(keyword, name)
+      end
+
+      def visit_examples_name(keyword, name)
+        visit_feature_element_name(keyword, name)
+      end
+
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+        visit_feature_element_name(keyword, name)
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/pretty.rb

@@ -0,0 +1,222 @@
+require 'cucumber/formatter/console'
+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 < Ast::Visitor
+      include FileUtils
+      include Console
+      attr_writer :indent
+
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @io = io
+        @options = options
+        @exceptions = []
+        @indent = 0
+        @prefixes = options[:prefixes] || {}
+      end
+
+      def visit_features(features)
+        super
+        print_summary(features) unless @options[:autoformat]
+      end
+
+      def visit_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)
+          File.open(file, Cucumber.file_mode('w')) do |io|
+            @io = io
+            super
+          end
+        else
+          super
+        end
+      end
+
+      def visit_comment(comment)
+        comment.accept(self)
+      end
+
+      def visit_comment_line(comment_line)
+        @io.puts(comment_line.indent(@indent))
+        @io.flush
+      end
+
+      def visit_tags(tags)
+        tags.accept(self)
+        if @indent == 1
+          @io.puts
+          @io.flush
+        end
+      end
+
+      def visit_tag_name(tag_name)
+        tag = format_string("@#{tag_name}", :tag).indent(@indent)
+        @io.print(tag)
+        @io.flush
+        @indent = 1
+      end
+
+      def visit_feature_name(name)
+        @io.puts(name)
+        @io.puts
+        @io.flush
+      end
+
+      def visit_feature_element(feature_element)
+        record_tag_occurrences(feature_element, @options)
+        @indent = 2
+        @scenario_indent = 2
+        super
+        @io.puts
+        @io.flush
+      end
+
+      def visit_background(background)
+        @indent = 2
+        @scenario_indent = 2
+        @in_background = true
+        super
+        @in_background = nil
+        @io.puts
+        @io.flush
+      end
+
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+        visit_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_examples_array(examples_array)
+        @indent = 4
+        @io.puts
+        examples_array[0..-2].each { |ea| super(ea) }
+        @last_example = true
+        super(examples_array.last)
+        @last_example = nil
+      end
+      
+      def visit_examples_name(keyword, name)
+        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 visit_outline_table(outline_table)
+        super
+        @indent = 4
+        @io.puts unless @last_example
+      end
+      
+      def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+        visit_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def visit_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 visit_step(step)
+        @indent = 6
+        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
+        super
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        source_indent = nil unless @options[:source]
+        formatted_step_name = format_step(keyword, step_match, status, source_indent)
+        @io.puts(formatted_step_name.indent(@scenario_indent + 2))
+      end
+
+      def visit_multiline_arg(multiline_arg)
+        return if @options[:no_multiline]
+        @table = multiline_arg
+        super
+      end
+
+      def visit_exception(exception, status)
+        print_exception(exception, status, @indent)
+        @io.flush
+      end
+
+      def visit_table_row(table_row)
+        @col_index = 0
+        @io.print '  |'.indent(@indent-2)
+        super
+        @io.puts
+        if table_row.exception && !@exceptions.index(table_row.exception)
+          print_exception(table_row.exception, :failed, @indent)
+        end
+      end
+
+      def visit_py_string(string)
+        s = %{"""\n#{string}\n"""}.indent(@indent)
+        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
+        @io.puts(format_string(s, @status))
+        @io.flush
+      end
+
+      def visit_table_cell(cell)
+        super
+        @col_index += 1
+      end
+
+      def visit_table_cell_value(value, status)
+        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 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

data/lib/cucumber/formatter/profile.rb

@@ -0,0 +1,78 @@
+require 'cucumber/formatter/progress'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format profile</tt>
+    class Profile < Progress
+      NUMBER_OF_STEP_DEFINITONS_TO_SHOW = 10
+      NUMBER_OF_STEP_INVOCATIONS_TO_SHOW = 5
+
+      def initialize(step_mother, io, options)
+        super
+        @step_definition_durations = Hash.new { |h,step_definition| h[step_definition] = [] }
+      end
+
+      def visit_step(step)
+        @step_duration = Time.now
+        @step = step
+        super
+      end
+
+      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        duration = Time.now - @step_duration
+        super
+
+        if step_match.step_definition
+          description = format_step(keyword, step_match, status, nil)
+          @step_definition_durations[step_match.step_definition] << [duration, description, @step.file_colon_line]
+        end
+      end
+
+      def print_summary(features)
+        super
+        @io.puts "\n\nTop #{NUMBER_OF_STEP_DEFINITONS_TO_SHOW} average slowest steps with #{NUMBER_OF_STEP_INVOCATIONS_TO_SHOW} slowest matches:\n"
+
+        mean_durations = map_to_mean_durations(@step_definition_durations)
+        mean_durations = mean_durations.sort_by do |duration_description_location, step_definition, mean_duration| 
+          mean_duration
+        end.reverse
+
+        mean_durations[0...NUMBER_OF_STEP_DEFINITONS_TO_SHOW].each do |duration_description_location, step_definition, mean_duration|
+          print_step_definition(step_definition, mean_duration)
+          duration_description_location = duration_description_location.sort_by do |duration, description, location| 
+            duration 
+          end.reverse
+          print_step_definitions(duration_description_location, step_definition)
+        end
+      end
+
+      private
+
+      def map_to_mean_durations(step_definition_durations)
+        mean_durations = []
+        step_definition_durations.each do |step_definition, duration_description_location|
+          total_duration = duration_description_location.inject(0) { |sum, step_details| step_details[0] + sum }
+          mean_duration = total_duration / duration_description_location.length
+
+          mean_durations << [duration_description_location, step_definition, mean_duration]
+        end
+        mean_durations
+      end
+
+      def print_step_definition(step_definition, mean_duration)
+        duration = sprintf("%.7f",  mean_duration)
+        @io.puts format_string("#{duration} #{step_definition.backtrace_line}", :failed)
+      end
+
+      def print_step_definitions(duration_description_location, step_definition)
+        max_length = duration_description_location[0...NUMBER_OF_STEP_INVOCATIONS_TO_SHOW].map{|_, d, _| d.jlength}.max
+        duration_description_location[0...NUMBER_OF_STEP_INVOCATIONS_TO_SHOW].each do |duration, description, location|
+          @io.print format_string("  #{sprintf("%.7f", duration)}", :pending)
+          @io.print "  #{description}"
+          @io.print format_string("  # #{location}".indent(max_length - description.jlength), :comment)
+          @io.puts
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/progress.rb

@@ -0,0 +1,67 @@
+require 'cucumber/formatter/console'
+
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format progress</tt>
+    class Progress < Ast::Visitor
+      include Console
+
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @io = io
+        @options = options
+      end
+
+      def visit_features(features)
+        super
+        @io.puts
+        @io.puts
+        print_summary(features)
+      end
+
+      def visit_feature_element(feature_element)
+        record_tag_occurrences(feature_element, @options)
+        super
+      end
+
+      def visit_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        progress(status)
+        @status = status
+      end
+
+      def visit_table_cell_value(value, status)
+        status ||= @status
+        progress(status) unless table_header_cell?(status)
+      end
+
+      private
+
+      def print_summary(features)
+        print_steps(:pending)
+        print_steps(:failed)
+        print_stats(features)
+        print_snippets(@options)
+        print_passing_wip(@options)
+        print_tag_limit_warnings(@options)
+      end
+
+      CHARS = {
+        :passed    => '.',
+        :failed    => 'F',
+        :undefined => 'U',
+        :pending   => 'P',
+        :skipped   => '-'
+      }
+
+      def progress(status)
+        char = CHARS[status]
+        @io.print(format_string(char, status))
+        @io.flush
+      end
+
+      def table_header_cell?(status)
+        status == :skipped_param
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/rerun.rb

@@ -0,0 +1,46 @@
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format rerun</tt>
+    #
+    # This formatter keeps track of all failing features and print out their location.
+    # Example:
+    #
+    #   features/foo.feature:34 features/bar.feature:11:76:81
+    #
+    # This formatter is used by AutoTest - it will use the output to decide what
+    # to run the next time, simply passing the output string on the command line.
+    #
+    class Rerun < Ast::Visitor
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @io = io
+        @options = options
+        @file_names = []
+        @file_colon_lines = Hash.new{|h,k| h[k] = []}
+      end
+
+      def visit_features(features)
+        super
+        files = @file_names.uniq.map do |file|
+          lines = @file_colon_lines[file]
+          "#{file}:#{lines.join(':')}"
+        end
+        @io.puts files.join(' ')
+      end
+
+      def visit_feature_element(feature_element)
+        @rerun = false
+        super
+        if @rerun
+          file, line = *feature_element.file_colon_line.split(':')
+          @file_colon_lines[file] << line
+          @file_names << file
+        end
+      end
+
+      def visit_step_name(keyword, step_match, status, source_indent, background)
+        @rerun = true if [:failed].index(status)
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/steps.rb

@@ -0,0 +1,50 @@
+module Cucumber
+  module Formatter
+    # The formatter used for <tt>--format steps</tt>
+    class Steps < Ast::Visitor
+
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @io = io
+        @options = options
+        @step_definition_files = collect_steps(step_mother)
+      end
+
+      def visit_features(features)
+        print_summary
+      end
+
+      private
+
+      def print_summary
+        count = 0
+        @step_definition_files.keys.sort.each do |step_definition_file|
+          @io.puts step_definition_file
+          
+          sources = @step_definition_files[step_definition_file]
+          source_indent = source_indent(sources)
+          sources.sort.each do |file_colon_line, regexp|
+            @io.print "#{regexp}".indent(2)
+            @io.print " # #{file_colon_line}".indent(source_indent - regexp.size)
+            @io.puts
+          end
+          @io.puts
+          count += sources.size
+        end
+        @io.puts "#{count} step definition(s) in #{@step_definition_files.size} source file(s)."
+      end
+
+      def collect_steps(step_mother)
+        step_mother.step_definitions.inject({}) do |step_definitions, step_definition|
+          step_definitions[step_definition.file] ||= []
+          step_definitions[step_definition.file] << [ step_definition.file_colon_line, step_definition.regexp.inspect ]
+          step_definitions
+        end
+      end
+
+      def source_indent(sources)
+        sources.map { |file_colon_line, regexp| regexp.size }.max + 1
+      end
+    end
+  end
+end