kosmas58-cucumber 0.1.99.22 → 0.1.99.23

data/lib/cucumber/cli/language_help_formatter.rb

@@ -0,0 +1,59 @@
+require 'cucumber/formatter/pretty'
+
+module Cucumber
+  module Cli
+    class LanguageHelpFormatter < Formatter::Pretty
+      INCOMPLETE = %{
+The Cucumber grammar has evolved since this translation was written.
+Please help us complete the translation by translating the missing words in
+
+#{Cucumber::LANGUAGE_FILE}
+
+Then contribute back to the Cucumber project. Details here:
+http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages
+}
+
+      def self.list_languages(io)
+        raw = Cucumber::LANGUAGES.keys.sort.map do |lang|
+          [lang, Cucumber::LANGUAGES[lang]['name'], Cucumber::LANGUAGES[lang]['native']]
+        end
+        table = Ast::Table.new(raw)
+        new(nil, io, {:check_lang=>true}, '').visit_multiline_arg(table, :passed)
+      end
+
+      def self.list_keywords(io, lang)
+        raw = Cucumber::KEYWORD_KEYS.map do |key|
+          [key, Cucumber::LANGUAGES[lang][key]]
+        end
+        table = Ast::Table.new(raw)
+        new(nil, io, {:incomplete => Cucumber.language_incomplete?(lang)}, '').visit_multiline_arg(table, :passed)
+      end
+
+      def visit_multiline_arg(table, status)
+        if @options[:incomplete]
+          @io.puts(format_string(INCOMPLETE, :failed))
+        end
+        super
+      end
+
+      def visit_table_row(table_row, status)
+        @col = 1
+        super
+      end
+
+      def visit_table_cell_value(value, width, status)
+        if @col == 1
+          if(@options[:check_lang])
+            @incomplete = Cucumber.language_incomplete?(value)
+          end
+          status = :comment 
+        elsif @incomplete
+          status = :undefined
+        end
+        
+        @col += 1
+        super(value, width, status)
+      end
+    end
+  end
+end

data/lib/cucumber/cli/main.rb

@@ -0,0 +1,107 @@
+require 'optparse'
+require 'cucumber'
+require 'ostruct'
+require 'cucumber/parser'
+require 'cucumber/formatter'
+require 'cucumber/cli/language_help_formatter'
+require 'cucumber/cli/configuration'
+
+module Cucumber
+  module Cli
+    class Main
+      class << self
+        def step_mother=(step_mother)
+          @step_mother = step_mother
+          @step_mother.extend(StepMother)
+          @step_mother.snippet_generator = StepDefinition
+        end
+
+        def execute(args)
+          new(args).execute!(@step_mother)
+        end
+      end
+
+      def initialize(args, out_stream = STDOUT, error_stream = STDERR)
+        @args         = args
+        @out_stream   = out_stream == STDOUT ? Formatter::ColorIO.new : out_stream
+        @error_stream = error_stream
+      end
+      
+      def execute!(step_mother)
+        configuration.load_language
+        step_mother.options = configuration.options
+
+        require_files
+
+        if(configuration.print_step_definitions?)
+          step_mother.print_step_definitions(@out_stream)
+          Kernel.exit(0)
+          return # In specs, exit is stubbed
+        end
+        
+        enable_diffing
+      
+        features = load_plain_text_features
+
+        visitor = configuration.build_formatter_broadcaster(step_mother)
+        visitor.visit_features(features)
+      
+        failure = features.steps[:failed].any? || (configuration.strict? && features.steps[:undefined].any?)
+        Kernel.exit(failure ? 1 : 0)
+      end
+
+      private
+
+      def configuration
+        return @configuration if @configuration
+      
+        @configuration = Configuration.new(@out_stream, @error_stream)
+        @configuration.parse!(@args)
+        @configuration
+      end
+    
+      def require_files
+        verbose_log("Ruby files required:")
+        configuration.files_to_require.each do |lib|
+          begin
+            require lib
+            verbose_log("  * #{lib}")
+          rescue LoadError => e
+            e.message << "\nFailed to load #{lib}"
+            raise e
+          end
+        end
+        verbose_log("\n")
+      end
+
+      def load_plain_text_features
+        filter = configuration.ast_filter
+        features = Ast::Features.new(filter)
+        parser = Parser::FeatureParser.new
+
+        verbose_log("Features:")
+        configuration.feature_files.each do |f|
+          features.add_feature(parser.parse_file(f))
+          verbose_log("  * #{f}")
+        end
+        verbose_log("\n"*2)
+        features
+      end
+
+      def verbose_log(string)
+        @out_stream.puts(string) if configuration.verbose?
+      end
+
+      def enable_diffing
+        if configuration.diff_enabled? && defined?(::Spec)
+          require 'spec/expectations/differs/default'
+          options = OpenStruct.new(:diff_format => :unified, :context_lines => 3)
+          ::Spec::Expectations.differ = ::Spec::Expectations::Differs::Default.new(options)
+        end
+      end
+    
+    end
+  end
+end
+
+Cucumber::Cli::Main.step_mother = self

data/lib/cucumber/core_ext/exception.rb

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

@@ -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{color_io pretty progress profile rerun html}.each{|n| require "cucumber/formatter/#{n}"}

data/lib/cucumber/formatter/ansicolor.rb

@@ -0,0 +1,103 @@
+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
+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>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',
+        'thead'     => 'cyan',
+        '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