kosmas58-cucumber 0.1.99.22 → 0.1.99.23

data/lib/cucumber/formatter/color_io.rb

@@ -0,0 +1,23 @@
+require 'forwardable'
+
+module Cucumber
+  module Formatter
+    # Adapter to make #puts/#print/#flush work with colours on Windows
+    class ColorIO
+      extend Forwardable
+      def_delegators :@kernel, :puts, :print # win32console colours only work when sent to Kernel
+      def_delegators :@stdout, :flush, :tty?
+
+      def initialize
+        @kernel = Kernel
+        @stdout = STDOUT
+      end
+
+      # Ensure using << still gets colours in win32console
+      def <<(output)
+        print(output)
+        self
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/console.rb

@@ -0,0 +1,119 @@
+require 'cucumber/formatter/ansicolor'
+
+module Cucumber
+  module Formatter
+    module Console
+      extend ANSIColor
+      FORMATS = Hash.new{|hash, format| hash[format] = method(format).to_proc}
+
+      def format_step(keyword, step_name, status, step_definition, source_indent)
+        comment = if source_indent && step_definition
+          c = (' # ' + step_definition.file_colon_line).indent(source_indent)
+          format_string(c, :comment)
+        else
+          ''
+        end
+
+        begin
+          line = keyword + " " + step_definition.format_args(step_name, format_for(status, :param)) + comment
+        rescue
+          # It didn't match. This often happens for :outline steps
+          line = keyword + " " + step_name + comment
+        end
+
+        format_string(line, status)
+      end
+
+      def format_string(string, status)
+        fmt = format_for(status)
+        if Proc === fmt
+          fmt.call(string)
+        else
+          fmt % string
+        end
+      end
+
+      def print_undefined_scenarios(features)
+        elements = features.scenarios.select{|scenario| scenario.undefined?}
+        print_elements(elements, :undefined, 'scenarios')
+      end
+
+      def print_steps(features, status)
+        print_elements(features.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, 0)
+          else
+            @io.puts(format_string(element.backtrace_line, status))
+          end
+          @io.puts
+          @io.flush
+        end
+      end
+
+      def print_counts(features)
+        @io.puts dump_count(features.scenarios.length, "scenario")
+
+        [:failed, :skipped, :undefined, :pending, :passed].each do |status|
+          if features.steps[status].any?
+            count_string = dump_count(features.steps[status].length, "step", status.to_s)
+            @io.puts format_string(count_string, status)
+            @io.flush
+          end
+        end
+      end
+
+      def print_exception(e, indent)
+        status = Cucumber::EXCEPTION_STATUS[e.class]
+        @io.puts(format_string("#{e.message} (#{e.class})\n#{e.backtrace.join("\n")}".indent(indent), status))
+      end
+
+      def print_snippets(features, options)
+        return unless options[:snippets]
+        undefined = features.steps[:undefined]
+        return if undefined.empty?
+        snippets = undefined.map do |step|
+          step_name = Undefined === step.exception ? step.exception.step_name : step.name
+          snippet = @step_mother.snippet_text(step.actual_keyword, step_name)
+          snippet
+        end.compact.uniq
+
+        text = "\nYou can implement step definitions for missing steps with these snippets:\n\n"
+        text += snippets.join("\n\n")
+
+        @io.puts format_string(text, :undefined)
+        @io.puts
+        @io.flush
+      end
+
+    private
+
+      def with_color
+        c = Term::ANSIColor.coloring?
+        Term::ANSIColor.coloring = @io.tty?
+        yield
+        Term::ANSIColor.coloring = c
+      end
+
+      def dump_count(count, what, state=nil)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      end
+
+      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/cucumber/formatter/cucumber.css

@@ -0,0 +1,55 @@
+
+
+
+
+
+.cucumber {
+  background: black;
+  color: white;
+  padding: 1em;
+}
+.cucumber .passed {
+  color: green;
+}
+.cucumber .undefined {
+  color: yellow;
+}
+.cucumber .pending {
+  color: yellow;
+}
+.cucumber .failed {
+  color: red;
+}
+.cucumber .skipped {
+  color: cyan;
+}
+.cucumber .outline {
+  color: cyan;
+}
+.cucumber .param {
+  font-weight: bold;
+}
+.cucumber a {
+  text-decoration: none;
+  color: inherit;
+}
+.cucumber a:hover {
+  text-decoration: underline;
+}
+.cucumber a:visited {
+  font-weight: normal;
+}
+.cucumber ol {
+  list-style: none;
+}
+.cucumber .stats {
+  margin: 2em;
+}
+.cucumber .summary ul.features li {
+  display: inline;
+}
+.cucumber .backtrace {
+  margin-top: 0;
+  margin-bottom: 0;
+  margin-left: 1em;
+}

data/lib/cucumber/formatter/cucumber.sass

@@ -0,0 +1,49 @@
+# cucumber.css is generated from cucumber.sass
+# Regenerate with the following command:
+#
+#   sass -t expanded lib/cucumber/formatter/cucumber.sass > lib/cucumber/formatter/cucumber.css
+#
+.cucumber
+  :background black
+  :color white
+  :padding 1em
+
+  .passed
+    :color green
+  .undefined
+    :color yellow
+  .pending
+    :color yellow
+  .failed
+    :color red
+  .skipped
+    :color cyan
+  .outline
+    :color cyan
+  .param
+    :font-weight bold
+
+  a
+    :text-decoration none
+    :color inherit
+
+    &:hover
+      :text-decoration underline
+    &:visited
+      :font-weight normal
+
+  ol
+    :list-style none
+
+  .stats
+    :margin 2em
+
+  .summary
+    ul.features
+      li
+        :display inline
+
+  .backtrace
+    :margin-top 0
+    :margin-bottom 0
+    :margin-left 1em

data/lib/cucumber/formatter/html.rb

@@ -0,0 +1,126 @@
+begin
+  require 'builder'
+rescue LoadError
+  gem 'builder'
+  require 'builder'
+end
+
+module Cucumber
+  module Formatter
+    class Html < Ast::Visitor
+      def initialize(step_mother, io, options)
+        super(step_mother)
+        @builder = Builder::XmlMarkup.new(:target => io, :indent => 2)
+      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.title 'Cucumber'
+            inline_css
+          end
+          @builder.body do
+            @builder.div(:class => 'cucumber') do
+              super
+            end
+          end
+        end
+      end
+
+      def visit_feature(feature)
+        @builder.div(:class => 'feature') do
+          super
+        end
+      end
+
+      def visit_feature_name(name)
+        lines = name.split(/\r?\n/)
+        @builder.h2(lines[0])
+        @builder.p 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
+          @builder.ol do
+            super
+          end
+        end
+      end
+
+      def visit_feature_element(feature_element)
+        @builder.div(:class => 'scenario') do
+          super
+        end
+        @open_step_list = true
+      end
+      
+      def visit_scenario_name(keyword, name, file_line, source_indent)
+        @builder.h3("#{keyword} #{name}")
+      end
+
+      def visit_outline_table(outline_table)
+        @builder.table do
+          super(outline_table)
+        end
+      end
+
+      def visit_examples_name(keyword, name)
+        @builder.h4("#{keyword} #{name}")
+      end
+
+      def visit_steps(scenarios)
+        @builder.ol do
+          super
+        end
+      end
+
+      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
+        @builder.li("#{keyword} #{step_name}", :class => status)
+      end
+
+      def visit_multiline_arg(multiline_arg, status)
+        if Ast::Table === multiline_arg
+          @builder.table do
+            super(multiline_arg, status)
+          end
+        else
+          @builder.p do
+            super(multiline_arg, status)
+          end
+        end
+      end
+
+      def visit_table_row(table_row, status)
+        @builder.tr do
+          super(table_row, status)
+        end
+      end
+
+      def visit_table_cell_value(value, width, status)
+        @builder.td(value, :class => status)
+      end
+
+      private
+
+      def inline_css
+        @builder.style(:type => 'text/css') do
+          @builder.text!(File.read(File.dirname(__FILE__) + '/cucumber.css'))
+        end
+      end
+
+    end
+  end
+end

data/lib/cucumber/formatter/pretty.rb

@@ -0,0 +1,167 @@
+require 'cucumber/formatter/console'
+require 'fileutils'
+
+module Cucumber
+  module 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, delim='|')
+        super(step_mother)
+        @io = io
+        @options = options
+        @delim = delim
+        @indent = 0
+      end
+
+      def visit_features(features)
+        super
+        print_summary(features) unless @options[:autoformat]
+      end
+
+      def visit_feature(feature)
+        @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
+            with_color do
+              feature.accept(self)
+            end
+          end
+        else
+          with_color do
+            feature.accept(self)
+          end
+        end
+      end
+
+      def visit_comment(comment)
+        comment.accept(self)
+      end
+
+      def visit_comment_line(comment_line)
+        unless comment_line.blank?
+          @io.puts(comment_line.indent(@indent)) 
+          @io.flush
+        end
+      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)
+        @indent = 2
+        @last_undefined = feature_element.undefined?
+        feature_element.accept(self)
+        @io.puts
+        @io.flush
+      end
+
+     def visit_background(background)
+        @indent = 2
+        background_already_visible = background.already_visited_steps?
+        background.accept(self)
+        @io.puts unless background_already_visible
+      end
+
+      def visit_examples(examples)
+        examples.accept(self)
+      end
+
+      def visit_examples_name(keyword, name)
+        @io.puts("\n  #{keyword} #{name}")
+        @io.flush
+        @indent = 4
+      end
+
+      def visit_scenario_name(keyword, name, file_line, source_indent)
+        line = "  #{keyword} #{name}"
+        line = format_string(line, :undefined) if @last_undefined
+        @io.print(line)
+        if @options[:source]
+          line_comment = " # #{file_line}".indent(source_indent)
+          @io.print(format_string(line_comment, :comment))
+        end
+        @io.puts
+        @io.flush
+      end
+
+      def visit_step(step)
+        @indent = 6
+        exception = step.accept(self)
+        print_exception(exception, @indent) if exception
+      end
+
+      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
+        source_indent = nil unless @options[:source]
+        formatted_step_name = format_step(keyword, step_name, status, step_definition, source_indent)
+        @io.puts("    " + formatted_step_name)
+        @io.flush
+      end
+
+      def visit_multiline_arg(multiline_arg, status)
+        return if @options[:no_multiline]
+        multiline_arg.accept(self, status)
+      end
+
+      def visit_table_row(table_row, status)
+        @io.print @delim.indent(@indent)
+        exception = table_row.accept(self, status)
+        @io.puts
+        print_exception(exception, 6) if exception
+      end
+
+      def visit_py_string(string, status)
+        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(table_cell, status)
+        table_cell.accept(self, status)
+      end
+
+      def visit_table_cell_value(value, width, status)
+        @io.print(' ' + format_string((value.to_s || '').ljust(width), status) + " #{@delim}")
+        @io.flush
+      end
+
+      private
+
+      def print_summary(features)
+        print_counts(features)
+        print_snippets(features, @options)
+      end
+
+    end
+  end
+end