aslakhellesoy-cucumber 0.1.16.4 → 0.1.16.5

data/lib/cucumber/core_ext/proc.rb

@@ -1,69 +1,33 @@
-module Cucumber
-  class ArityMismatchError < StandardError
-  end
-
-  module CoreExt
-    # Proc extension that allows a proc to be called in the context of any object.
-    # Also makes it possible to tack a name onto a Proc.
-    module CallIn
-      PROC_PATTERN = /[\d\w]+@(.*):(.*)>/
-      
-      if Proc.new{}.to_s =~ PROC_PATTERN
-        def to_backtrace_line
-          "#{file_colon_line}:in `#{name}'"
-        end
-
-        def to_comment_line
-          "# #{file_colon_line}"
-        end
-
-        def file_colon_line
-          path, line = *to_s.match(PROC_PATTERN)[1..2]
-          path = File.expand_path(path)
-          pwd = Dir.pwd
-          path = path[pwd.length+1..-1]
-          "#{path}:#{line}"
-        end
-      else
-        # This Ruby implementation doesn't implement Proc#to_s correctly
-        STDERR.puts "*** THIS RUBY IMPLEMENTATION DOESN'T REPORT FILE AND LINE FOR PROCS ***"
-        
-        def to_backtrace_line
-          nil
-        end
-
-        def to_comment_line
-          ""
-        end
-      end
-      
-      attr_accessor :name
-      
-      def call_in(obj, *args)
-        obj.extend(mod)
-        if self != StepMother::PENDING && args.length != arity2
-          # We have to manually raise when the block has arity -1 (no pipes)
-          raise ArityMismatchError.new("expected #{arity2} block argument(s), got #{args.length}")
-        else
-          obj.__send__(meth, *args)
-        end
-      end
+# Proc extension to get more location info out of a proc
+class Proc
+  PROC_PATTERN = /[\d\w]+@(.*):(.*)>/
+  
+  if Proc.new{}.to_s =~ PROC_PATTERN
+    def to_backtrace_line(name)
+      "#{file_colon_line}:in `#{name}'"
+    end
 
-      def arity2
-        arity == -1 ? 0 : arity
-      end
+    def to_comment_line
+      "# #{file_colon_line}"
+    end
 
-      def meth
-        @meth ||= "__cucumber_#{object_id}"
-      end
+    def file_colon_line
+      path, line = *to_s.match(PROC_PATTERN)[1..2]
+      path = File.expand_path(path)
+      pwd = Dir.pwd
+      path = path[pwd.length+1..-1]
+      "#{path}:#{line}"
+    end
+  else
+    # This Ruby implementation doesn't implement Proc#to_s correctly
+    STDERR.puts "*** THIS RUBY IMPLEMENTATION DOESN'T REPORT FILE AND LINE FOR PROCS ***"
+    
+    def to_backtrace_line
+      nil
+    end
 
-      def mod
-        p = self
-        m = meth
-        @mod ||= Module.new do
-          define_method(m, &p)
-        end
-      end
-    end 
+    def to_comment_line
+      ""
+    end
   end
-end
+end 

data/lib/cucumber/core_ext/string.rb

@@ -1,4 +1,21 @@
 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?
@@ -8,6 +25,8 @@ class String
     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

data/lib/cucumber/{formatters → formatter}/ansicolor.rb

@@ -17,7 +17,7 @@ end
 Term::ANSIColor.coloring = false if !STDOUT.tty? || (Cucumber::WINDOWS && !Cucumber::WINDOWS_MRI)
 
 module Cucumber
-  module Formatters
+  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
@@ -25,7 +25,7 @@ module Cucumber
     #
     # The colours that you can change are:
     #
-    # * <tt>missing</tt>       - defaults to <tt>yellow</tt>
+    # * <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>
@@ -69,14 +69,15 @@ module Cucumber
           h[$1] + ',bold'
         end
       end.merge({
-        'missing' => 'yellow',
-        'pending' => 'yellow',
-        'failed'  => 'red',
-        'passed'  => 'green',
-        'outline' => 'cyan',
-        'skipped' => 'cyan',
-        'comment' => 'grey',
-        'tag'     => 'blue'
+        '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"

data/lib/cucumber/formatter/console.rb

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,158 @@
+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

@@ -0,0 +1,77 @@
+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

@@ -0,0 +1,68 @@
+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.rb

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

data/lib/cucumber/formatters/autotest_formatter.rb

@@ -1,5 +1,3 @@
-require 'cucumber/formatters/ansicolor'
-
 module Cucumber
   module Formatters
     class AutotestFormatter

data/lib/cucumber/formatters/html_formatter.rb

@@ -55,16 +55,16 @@ HTML
       end
 
       def visit_regular_scenario(scenario)
-        visit_scenario(scenario, Cucumber.language['scenario'])
+        visit_scenario(scenario, Cucumber.keywords['scenario'])
       end
 
       def visit_scenario_outline(scenario)
-        visit_scenario(scenario, Cucumber.language['scenario_outline'])
+        visit_scenario(scenario, Cucumber.keywords['scenario_outline'])
       end
 
       def visit_row_scenario(scenario)
         @io.puts %{          <dl class="new">}
-        @io.puts %{            <dt>#{Cucumber.language['scenario']}: #{scenario.name}</dt>}
+        @io.puts %{            <dt>#{Cucumber.keywords['scenario']}: #{scenario.name}</dt>}
         @io.puts %{            <dd>}
         @io.puts %{              <table cellpadding="3">}
         @io.puts %{                <thead>}
@@ -130,6 +130,7 @@ HTML
   </body>
 </html>
 HTML
+        @io.flush
       end
       
       private

data/lib/cucumber/formatters/pretty_formatter.rb

@@ -170,7 +170,7 @@ module Cucumber
 
       def output_failing_step(step)
         @io.puts failed("      #{step.error.message.split("\n").join(INDENT)} (#{step.error.class})")
-        @io.puts failed("      #{step.error.cucumber_backtrace.join(INDENT)}")
+        @io.puts failed("      #{step.error.backtrace.join(INDENT)}")
       end
 
       def dump

data/lib/cucumber/formatters/unicode.rb

@@ -1,6 +1,6 @@
 # Require this file if you need Unicode support.
 require 'cucumber/platform'
-require 'cucumber/formatters/ansicolor'
+require 'cucumber/formatter/ansicolor'
 
 $KCODE='u' unless Cucumber::RUBY_1_9
 
@@ -16,7 +16,7 @@ if Cucumber::WINDOWS_MRI && `chcp` =~ /Active code page: (\d+)/
       alias cucumber_print print
       def print(*a)
         begin
-          cucumber_print *Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a)
+          cucumber_print(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a))
         rescue Iconv::IllegalSequence
           cucumber_print(*a)
         end
@@ -25,7 +25,7 @@ if Cucumber::WINDOWS_MRI && `chcp` =~ /Active code page: (\d+)/
       alias cucumber_puts puts
       def puts(*a)
         begin
-          cucumber_puts *Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a)
+          cucumber_puts(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a))
         rescue Iconv::IllegalSequence
           cucumber_puts(*a)
         end