cucumber 0.1.16 → 0.2.0

data/lib/cucumber/core_ext/exception.rb

@@ -1,20 +1,53 @@
+# Exception extension that tweaks Exception backtraces:
+#
+# * The line of the failing .feature line is appended to the backtrace
+# * The line that calls #cucumber_instance_exec is replaced with the StepDefinition's regexp
+# * Non intersting lines are stripped out
+#
+# The result is that backtraces look like this:
+#
+#   features/step_definitions/the_step_definition.rb:in `/some step/'
+#   features/the_feature_file.feature:41:in `Given some step'
+#
+# or if the exception is raised in the tested code:
+#
+#   lib/myapp/some_file.rb:in `/some_method/'
+#   lib/myapp/some_other_file.rb:in `/some_other_method/'
+#   features/step_definitions/the_step_definition.rb:in `/some step/'
+#   features/the_feature_file.feature:41:in `Given some step'
+#
+# All backtrace munging can be turned off with the <tt>--backtrace</tt> switch
+#
 class Exception
   CUCUMBER_FILTER_PATTERNS = [
-    /vendor\/rails/, 
-    /vendor\/plugins\/cucumber/, 
-    /vendor\/plugins\/rspec/,
-    /gems\/rspec/
+    /vendor\/rails|lib\/cucumber|lib\/rspec|gems\//
   ]
 
+  INSTANCE_EXEC_OFFSET = (Cucumber::RUBY_1_9 || Cucumber::JRUBY) ? -3 : -4
+
   def self.cucumber_full_backtrace=(v)
     @@cucumber_full_backtrace = v
   end
   self.cucumber_full_backtrace = false
 
-  def cucumber_backtrace
-    return (backtrace || []) if @@cucumber_full_backtrace
-    (backtrace || []).map {|b| b.split("\n") }.flatten.reject do |line|
+  # Strips the backtrace from +line+ and down
+  def self.cucumber_strip_backtrace!(backtrace, instance_exec_invocation_line, pseudo_method)
+    return if @@cucumber_full_backtrace
+
+    instance_exec_pos = backtrace.index(instance_exec_invocation_line)
+    if instance_exec_pos
+      replacement_line = instance_exec_pos + INSTANCE_EXEC_OFFSET
+      backtrace[replacement_line].gsub!(/`.*'/, "`#{pseudo_method}'") if pseudo_method
+      backtrace[replacement_line+1..-1] = nil
+
+      backtrace.compact!
+    else
+      # This happens with rails, because they screw up the backtrace
+      # before we get here (injecting erb stacktrace and such)
+    end
+
+    backtrace.reject! do |line|
       CUCUMBER_FILTER_PATTERNS.detect{|p| line =~ p}
-    end.map { |line| line.strip }
+    end
   end
 end

data/lib/cucumber/core_ext/instance_exec.rb

@@ -0,0 +1,54 @@
+require 'cucumber/platform'
+
+module Cucumber
+  class ArityMismatchError < StandardError
+  end
+end
+
+class Object
+  def cucumber_instance_exec(check_arity, pseudo_method, *args, &block)
+    arity = block.arity
+    arity = 0 if arity == -1
+    cucumber_run_with_backtrace_filtering(pseudo_method) do
+      if check_arity && args.length != arity
+        instance_exec do
+          raise Cucumber::ArityMismatchError.new("expected #{arity} block argument(s), got #{args.length}")
+        end
+      else
+        instance_exec(*args, &block)
+      end
+    end
+  end
+  
+  def cucumber_run_with_backtrace_filtering(pseudo_method)
+    begin
+      yield
+    rescue Exception => e
+      instance_exec_invocation_line = "#{__FILE__}:#{__LINE__ - 2}:in `cucumber_run_with_backtrace_filtering'"
+      Exception.cucumber_strip_backtrace!((e.backtrace || []), instance_exec_invocation_line, pseudo_method)
+      raise e
+    end
+  end
+  
+  unless defined? instance_exec # 1.9
+    # http://eigenclass.org/hiki/bounded+space+instance_exec
+    module InstanceExecHelper; end
+    include InstanceExecHelper
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(mname="__instance_exec#{n}")
+        InstanceExecHelper.module_eval{ define_method(mname, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+      begin
+        ret = send(mname, *args)
+      ensure
+        InstanceExecHelper.module_eval{ remove_method(mname) } rescue nil
+      end
+      ret
+    end
+  end
+end

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 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 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/formatter.rb

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

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

@@ -1,15 +1,12 @@
-# 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
+    gem 'win32console', '>= 1.2.0'
     require 'Win32/Console/ANSI'
   rescue LoadError
-    STDERR.puts "You must gem install win32console to get coloured output on MRI/Windows"
+    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
 end
@@ -17,7 +14,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 +22,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>
@@ -37,7 +34,7 @@ module Cucumber
     # * <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>
+    # * <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
@@ -69,14 +66,14 @@ 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',
+        'outline'   => 'cyan',
+        'skipped'   => 'cyan',
+        'comment'   => 'grey',
+        'tag'       => 'cyan'
       })
 
       if ENV['CUCUMBER_COLORS'] # Example: export CUCUMBER_COLORS="passed=red:failed=yellow"

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,109 @@
+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
+          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
+
+      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