aslakhellesoy-cucumber 0.1.99.4 → 0.1.99.5

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

@@ -0,0 +1,33 @@
+# 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 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
+end 

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

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

data/lib/cucumber/formatter/ansicolor.rb

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

@@ -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