aslakhellesoy-cucumber 0.1.99.3 → 0.1.99.4

data/lib/cucumber/formatter/ansicolor.rb

@@ -1,106 +0,0 @@
-# Hack to work around Win32/Console, which bundles a licence-violating, outdated
-# copy of term/ansicolor that doesn't implement Term::ANSIColor#coloring=.
-# We want the official one!
-gem 'term-ansicolor'
-$LOAD_PATH.each{|path| $LOAD_PATH.unshift($LOAD_PATH.delete(path)) if path =~ /term-ansicolor/}
-require 'term/ansicolor'
-
-if Cucumber::WINDOWS_MRI
-  begin
-    require 'Win32/Console/ANSI'
-  rescue LoadError
-    STDERR.puts "You must gem install win32console to get coloured output on MRI/Windows"
-    Term::ANSIColor.coloring = false
-  end
-end
-
-Term::ANSIColor.coloring = false if !STDOUT.tty? || (Cucumber::WINDOWS && !Cucumber::WINDOWS_MRI)
-
-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>blue</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',
-        'thead'     => 'cyan',
-        'outline'   => 'cyan',
-        'skipped'   => 'cyan',
-        'comment'   => 'grey',
-        'tag'       => 'blue'
-      })
-
-      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/console.rb

@@ -1,116 +0,0 @@
-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)
-        line = if step_definition # nil for :outline
-          comment = if source_indent
-            c = (' # ' + step_definition.file_colon_line).indent(source_indent)
-            format_string(c, :comment)
-          else
-            ''
-          end
-          keyword + " " + step_definition.format_args(step_name, format_for(status, :param)) + comment
-        else
-          keyword + " " + step_name
-        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 = StepMother::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/pretty.rb

@@ -1,158 +0,0 @@
-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
-      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_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)
-        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 || '').ljust(width), status) + " #{@delim}")
-        @io.flush
-      end
-
-      private
-
-      def print_summary(features)
-        print_counts(features)
-        print_snippets(features, @options)
-      end
-
-    end
-  end
-end

data/lib/cucumber/formatter/profile.rb

@@ -1,77 +0,0 @@
-require 'cucumber/formatter/progress'
-
-module Cucumber
-  module Formatter
-    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_name(keyword, step_name, status, step_definition, source_indent)
-        duration = Time.now - @step_duration
-        super
-
-        if step_definition # nil for outline steps
-          description = format_step(keyword, step_name, status, step_definition, nil)
-          @step_definition_durations[step_definition] << [duration, description, @step.file_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.to_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

@@ -1,68 +0,0 @@
-require 'cucumber/formatter/console'
-
-module Cucumber
-  module Formatter
-    class Progress < Ast::Visitor
-      include Console
-
-      def initialize(step_mother, io, options)
-        super(step_mother)
-        @io = io
-        @options = options
-      end
-
-      def visit_features(features)
-        with_color do
-          super
-          @io.puts
-          @io.puts
-          print_summary(features)
-        end
-      end
-
-      def visit_multiline_arg(multiline_arg, status)
-        @multiline_arg = true
-        super
-        @multiline_arg = false
-      end
-
-      def visit_feature_element(feature_element)
-        progress(:undefined) if feature_element.undefined?
-        super
-      end
-
-      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
-        progress(status) unless status == :outline
-      end
-
-      def visit_table_cell_value(value, width, status)
-        progress(status) if (status != :thead) && !@multiline_arg
-      end
-      
-      private
-
-      def print_summary(features)
-        print_undefined_scenarios(features)
-        print_steps(features, :pending)
-        print_steps(features, :failed)
-        print_counts(features)
-        print_snippets(features, @options)
-      end
-
-      CHARS = {
-        :passed    => '.',
-        :failed    => 'F',
-        :undefined => 'U',
-        :pending   => 'P',
-        :skipped   => 'S'
-      }
-
-      def progress(status)
-        char = CHARS[status]
-        @io.print(format_string(char, status))
-        @io.flush
-      end
-      
-    end
-  end
-end

data/lib/cucumber/formatter/rerun.rb

@@ -1,35 +0,0 @@
-module Cucumber
-  module Formatter
-    class Rerun < Ast::Visitor
-      def initialize(step_mother, io, options)
-        super(step_mother)
-        @io = io
-        @file_names = []
-        @file_lines = Hash.new{|h,k| h[k] = []}
-      end
-
-      def visit_features(features)
-        super
-        files = @file_names.uniq.map do |file|
-          lines = @file_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_line.split(':')
-          @file_lines[file] << line
-          @file_names << file
-        end
-      end
-
-      def visit_step_name(keyword, step_name, status, step_definition, source_indent)
-        @rerun = true if [:failed].index(status)
-      end
-    end
-  end
-end

data/lib/cucumber/formatter.rb

@@ -1 +0,0 @@
-%w{pretty progress profile rerun}.each{|n| require "cucumber/formatter/#{n}"}

data/lib/cucumber/formatters/autotest_formatter.rb

@@ -1,21 +0,0 @@
-module Cucumber
-  module Formatters
-    class AutotestFormatter
-      def initialize(io)
-        @io = io
-        @failed_scenarios = []
-      end
-      
-      def step_didnt_pass(step, regexp, args)
-        unless @failed_scenarios.include? step.scenario.name
-          @failed_scenarios << step.scenario.name
-          @io.puts step.scenario.name
-        end
-      end
-      
-      alias step_failed  step_didnt_pass
-      alias step_pending step_didnt_pass
-      alias step_skipped step_didnt_pass
-    end
-  end
-end