cavalle-cucumber 0.2.3.3.1

data/lib/cucumber/core_ext/string.rb

@@ -0,0 +1,48 @@
+class String
+  def indent(n)
+    if n >= 0
+      gsub(/^/, ' ' * n)
+    else
+      gsub(/^ {0,#{-n}}/, "")
+    end
+  end
+  
+  # re.source.gsub(/\([^)]*\)/, '$var')
+  # Cumulative #sub
+  def subs(re, *args)
+    args.inject(self) do |s,arg|
+      s.sub(re, arg)
+    end
+  end
+
+  # TODO: Use subs instead...
+  def gzub(regexp, format=nil, &proc)
+    md = match(regexp)
+    raise "#{self.inspect} doesn't match #{regexp.inspect}" if md.nil?
+    
+    s = dup
+    pos = 0
+    md.captures.each_with_index do |m, n|
+      replacement = if block_given?
+        proc.call(m)
+      elsif Proc === format
+        format.call(m)
+      else
+        format % m
+      end
+      
+      if md.offset(n+1)[0]
+        s[md.offset(n+1)[0] + pos, m.length] = replacement
+        pos += replacement.length - m.length
+      end
+    end
+    s
+  end
+
+  if (Cucumber::JRUBY && Cucumber::RAILS) || Cucumber::RUBY_1_9
+    # Workaround for http://tinyurl.com/55uu3u 
+    alias jlength length
+  else
+    require 'jcode'
+  end
+end

data/lib/cucumber/formatter/ansicolor.rb

@@ -0,0 +1,110 @@
+gem 'term-ansicolor'
+require 'term/ansicolor'
+
+if Cucumber::WINDOWS_MRI
+  begin
+    gem 'win32console', '>= 1.2.0'
+    require 'Win32/Console/ANSI'
+  rescue LoadError
+    STDERR.puts %{*** WARNING: You must "gem install win32console" (1.2.0 or higher) to get coloured output on MRI/Windows}
+    Term::ANSIColor.coloring = false
+  end
+elsif Cucumber::WINDOWS && Cucumber::JRUBY
+  begin
+    gem 'aslakhellesoy-ansicolor', '>= 1.0'
+    require 'ansicolor'
+  rescue LoadError
+    STDERR.puts %{*** WARNING: You must "gem install aslakhellesoy-ansicolor --source http://gems.github.com" (1.0 or higher) to get coloured output on JRuby/Windows}
+    Term::ANSIColor.coloring = false
+  end
+end
+
+Term::ANSIColor.coloring = false if !STDOUT.tty?
+
+module Cucumber
+  module Formatter
+    # Defines aliases for coloured output. You can tweak the colours by defining
+    # a <tt>CUCUMBER_COLORS</tt> variable in your shell, very much like you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # <a href="http://mipsisrisc.com/rambling/2008/06/27/lscolorsls_colors-now-with-linux-support/">$LSCOLORS/$LS_COLORS</a>
+    #
+    # The colours that you can change are:
+    #
+    # * <tt>undefined</tt>     - defaults to <tt>yellow</tt>
+    # * <tt>pending</tt>       - defaults to <tt>yellow</tt>
+    # * <tt>pending_param</tt> - defaults to <tt>yellow,bold</tt>
+    # * <tt>failed</tt>        - defaults to <tt>red</tt>
+    # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
+    # * <tt>passed</tt>        - defaults to <tt>green</tt>
+    # * <tt>passed_param</tt>  - defaults to <tt>green,bold</tt>
+    # * <tt>outline</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>outline_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>skipped</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>skipped_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>comment</tt>       - defaults to <tt>grey</tt>
+    # * <tt>tag</tt>           - defaults to <tt>cyan</tt>
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green. Examples:
+    #
+    #   export CUCUMBER_COLORS="passed=white"
+    #   export CUCUMBER_COLORS="passed=white,bold:passed_param=white,bold,underline"
+    #
+    # (If you're on Windows, use SET instead of export).
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+    #
+    # Although not listed, you can also use <tt>grey</tt>
+    module ANSIColor
+      include Term::ANSIColor
+
+      # Not supported in Term::ANSIColor
+      def grey(m)
+        if ::Term::ANSIColor.coloring?
+          "\e[90m#{m}\e[0m"
+        else
+          m
+        end
+      end
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_param/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'undefined' => 'yellow',
+        'pending'   => 'yellow',
+        'failed'    => 'red',
+        'passed'    => 'green',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comment'   => 'grey',
+        'tag'       => 'cyan'
+      })
+
+      if ENV['CUCUMBER_COLORS'] # Example: export CUCUMBER_COLORS="passed=red:failed=yellow"
+        ENV['CUCUMBER_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      ALIASES.each do |method, color|
+        unless method =~ /.*_param/
+          code = <<-EOF
+          def #{method}(string=nil, &proc)
+            #{ALIASES[method].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method].split(",").length}
+          end
+          # This resets the colour to the non-param colour
+          def #{method}_param(string=nil, &proc)
+            #{ALIASES[method+'_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method+'_param'].split(",").length} + #{ALIASES[method].split(",").join(' + ')}
+          end
+          EOF
+          eval(code)
+        end
+      end
+    end
+  end
+end

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,110 @@
+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_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(string, status)
+        fmt = format_for(status)
+        if Proc === fmt
+          fmt.call(string)
+        else
+          fmt % string
+        end
+      end
+
+      def print_steps(status)
+        print_elements(step_mother.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_counts
+        @io.puts dump_count(step_mother.scenarios.length, "scenario")
+
+        [:failed, :skipped, :undefined, :pending, :passed].each do |status|
+          if step_mother.steps(status).any?
+            count_string = dump_count(step_mother.steps(status).length, "step", status.to_s)
+            @io.puts format_string(count_string, status)
+            @io.flush
+          end
+        end
+      end
+
+      def print_exception(e, status, indent)
+        if @options[:strict] || !(Undefined === e) || e.nested?
+          @io.puts(format_string("#{e.message} (#{e.class})\n#{e.backtrace.join("\n")}".indent(indent), status))
+        end
+      end
+
+      def print_snippets(options)
+        return unless options[:snippets]
+        undefined = step_mother.steps(:undefined)
+        return if undefined.empty?
+        snippets = 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
+          snippet = @step_mother.snippet_text(step.actual_keyword, step_name, step_multiline_class)
+          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
+
+      def announce(announcement)
+        @io.puts
+        @io.puts(format_string(announcement, :tag))
+        @io.flush
+      end
+
+    private
+
+      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,186 @@
+require 'erb'
+begin
+  require 'builder'
+rescue LoadError
+  gem 'builder'
+  require 'builder'
+end
+
+module Cucumber
+  module Formatter
+    class Html < Ast::Visitor
+      include ERB::Util # for the #h method
+
+      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
+          super
+        end
+      end
+
+      def visit_background_name(keyword, name, file_colon_line, source_indent)
+        @builder.h3("#{keyword} #{name}")
+      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_colon_line, source_indent)
+        @builder.h3("#{keyword} #{name}")
+      end
+
+      def visit_outline_table(outline_table)
+        @outline_row = 0
+        @builder.table do
+          super(outline_table)
+        end
+        @outline_row = nil
+      end
+
+      def visit_examples_name(keyword, name)
+        @builder.h4("#{keyword} #{name}")
+      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)
+        @status = status
+        @builder.li(:id => @step_id, :class => 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 ||= []
+        @skip_step = @step_matches.index(step_match)
+        @step_matches << step_match
+
+        unless @skip_step
+          step_name = step_match.format_args(lambda{|param| "<span>#{param}</span>"})
+          @builder.div do |div|
+            div << h("#{keyword} #{step_name}")
+          end
+        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 => @status) do |pre|
+          pre << string
+        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, width, status)
+        cell_type = @outline_row == 0 ? :th : :td
+        attributes = {:id => "#{@row_id}_#{@col_index}"}
+        attributes[:class] = status if status
+        @builder.__send__(cell_type, value, attributes)
+        @col_index += 1
+      end
+
+      def announce(announcement)
+        @builder.pre(announcement, :class => 'announcement')
+      end
+
+      private
+
+      def inline_css
+        @builder.style(:type => 'text/css') do
+          @builder.text!(File.read(File.dirname(__FILE__) + '/cucumber.css'))
+        end
+      end
+
+      def format_exception(exception)
+        (["#{exception.message} (#{exception.class})"] + exception.backtrace).join("\n")
+      end
+    end
+  end
+end