cucumber 0.1.12 → 0.1.13

data/examples/tickets/features/step_definitons/scenario_outline_steps.rb

@@ -0,0 +1,34 @@
+Given /^there are (\d+) (\w+)$/ do |count, fruit|
+  @eattingMachine = EattingMachine.new(fruit, count)
+end
+
+Given "the belly space is < 12 and > 6" do
+end
+
+Given "I have the following fruits in my pantry" do |pantry_table|
+  @pantry = Pantry.new
+  pantry_table.hashes.each do |item|
+    @pantry.add(item['name'].downcase, item['quantity'])
+  end
+end
+
+When /^I eat (\d+) (\w+)$/ do |count, fruit|
+  @eattingMachine.eat(count)
+  @eattingMachine.belly_count = count.to_i
+end
+
+When /^I eat (\d+) (\w+) from the pantry$/ do |count, fruit|
+  @pantry.remove(fruit, count.to_i)
+end
+
+Then /^I should have (\d+) (\w+)$/ do |count, fruit|
+  @eattingMachine.fruit_total.should == count.to_i
+end
+
+Then /^I should have (\d+) (\w+) in my belly$/ do |count, fruit|
+  @eattingMachine.belly_count.should == count.to_i
+end
+
+Then /^I should have (\d+) (\w+) in the pantry$/ do |count, fruit|
+  @pantry.count(fruit).should == count.to_i
+end

data/examples/tickets/features/step_definitons/tickets_steps.rb

@@ -1,5 +1,9 @@
 require 'spec'
 
+World do
+  Object.new
+end
+
 Given "be_empty" do
   [1,2].should_not be_empty
 end

data/gem_tasks/fix_cr_lf.rake

@@ -2,7 +2,7 @@ desc 'Make all files use UNIX (\n) line endings'
 task :fix_cr_lf do
   files = FileList['**/*']
   files.each do |f|
-    next if File.directory?(f)
+    next if File.directory?(f) || f =~ /dos/
     s = IO.read(f)
     s.gsub!(/\r?\n/, "\n")
     File.open(f, "w") { |io| io.write(s) }

data/gem_tasks/yard.rake

@@ -0,0 +1,8 @@
+begin
+  require 'yard'
+  
+  YARD::Rake::YardocTask.new do |t|
+    t.files   = ['lib/**/*.rb']
+  end
+rescue LoadError => ignore
+end

data/lib/autotest/cucumber_mixin.rb

@@ -1,5 +1,6 @@
 require 'autotest'
 require 'tempfile'
+require File.dirname(__FILE__) + '/../cucumber/platform'
 
 module Autotest::CucumberMixin
   def self.included(receiver)
@@ -121,11 +122,10 @@ module Autotest::CucumberMixin
     else
       scenario_args = scenarios_to_run.map { |s| "-s '#{s}'" }.join(' ')
     end
-    
-    return "#{cucumber} #{args} #{scenario_args}"
+    return "#{$CUCUMBER_RUBY} #{cucumber} #{args} #{scenario_args}"
   end
   
   def cucumber
-    File.exist?("script/cucumber") ? "script/cucumber" : "cucumber"
+    File.file?("script/cucumber") ? "script/cucumber" : "cucumber"
   end
 end

data/lib/cucumber.rb

@@ -15,6 +15,8 @@ require 'cucumber/formatters'
 require 'cucumber/treetop_parser/feature_parser'
 require 'cucumber/cli'
 require 'cucumber/broadcaster'
+require 'cucumber/world'
+require 'cucumber/core_ext/exception'
 
 module Cucumber
   LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/cucumber/languages.yml')

data/lib/cucumber/broadcaster.rb

@@ -11,7 +11,7 @@ module Cucumber
 
     def method_missing(method_name, *args)
       @receivers.each  do |receiver|
-        r = (receiver == STDOUT) ? Kernel: receiver # Needed to make colors work on Windows
+        r = (receiver == STDOUT) ? Kernel : receiver # Needed to make colors work on Windows
         r.__send__(method_name, *args) if receiver.respond_to?(method_name)
       end
     end

data/lib/cucumber/cli.rb

@@ -2,13 +2,15 @@ require 'optparse'
 require 'cucumber'
 
 module Cucumber
+  class YmlLoadError < StandardError; end
+
   class CLI
     class << self
       attr_writer :step_mother, :executor, :features
 
-      def execute
+      def execute(args)
         @execute_called = true
-        parse(ARGV).execute!(@step_mother, @executor, @features)
+        parse(args).execute!(@step_mother, @executor, @features)
       end
 
       def execute_called?
@@ -44,11 +46,16 @@ module Cucumber
     end
 
     def parse_options!(args)
+      @args = args
       return parse_args_from_profile('default') if args.empty?
       args.extend(OptionParser::Arguable)
 
       args.options do |opts|
-        opts.banner = "Usage: cucumber [options] FILES|DIRS"
+        opts.banner = ["Usage: cucumber [options] [[FILE[:LINE[:LINE]*]] | [FILES|DIRS]]", "",
+          "Examples:",
+          "cucumber examples/i18n/en/features",
+          "cucumber --language it examples/i18n/it/features/somma.feature:6:98:113", "", ""
+        ].join("\n")
         opts.on("-r LIBRARY|DIR", "--require LIBRARY|DIR", "Require files before executing the features.",
           "If this option is not specified, all *.rb files that",
           "are siblings or below the features will be autorequired",
@@ -62,7 +69,7 @@ module Cucumber
           @options[:scenario_names] ||= []
           @options[:scenario_names] << v
         end
-        opts.on("-a LANG", "--language LANG", "Specify language for features (Default: #{@options[:lang]})",
+        opts.on("-l LANG", "--language LANG", "Specify language for features (Default: #{@options[:lang]})",
           "Available languages: #{Cucumber.languages.join(", ")}",
           "Look at #{Cucumber::LANGUAGE_FILE} for keywords") do |v|
           @options[:lang] = v
@@ -113,6 +120,9 @@ module Cucumber
           @options[:snippets] = false
           @options[:source] = false
         end
+        opts.on("-b", "--backtrace", "Show full backtrace for all errors") do
+          Exception.cucumber_full_backtrace = true
+        end
         opts.on("-v", "--verbose", "Show the files and features loaded") do
           @options[:verbose] = true
         end
@@ -135,33 +145,12 @@ module Cucumber
       @paths += args
     end
 
-    def parse_args_from_profile(profile)
-      unless File.exist?('cucumber.yml')
-        return exit_with_error("cucumber.yml was not found.  Please define your '#{profile}' and other profiles in cucumber.yml.\n"+
-                               "Type 'cucumber --help' for usage.\n")
-      end
-      
-      require 'yaml'
-      cucumber_yml = YAML::load(IO.read('cucumber.yml'))
-      args_from_yml = cucumber_yml[profile]
-      if args_from_yml.nil?
-        exit_with_error <<-END_OF_ERROR
-Could not find profile: '#{profile}'
-
-Defined profiles in cucumber.yml:
-  * #{cucumber_yml.keys.join("\n  * ")}
-        END_OF_ERROR
-      elsif !args_from_yml.is_a?(String)
-        exit_with_error "Profiles must be defined as a String.  The '#{profile}' profile was #{args_from_yml.inspect} (#{args_from_yml.class}).\n"
-      else
-        parse_options!(args_from_yml.split(' '))
-      end
-    end
 
     def execute!(step_mother, executor, features)
       Term::ANSIColor.coloring = @options[:color] unless @options[:color].nil?
       Cucumber.load_language(@options[:lang])
       require_files
+      enable_diffing
       executor.formatters = build_formatter_broadcaster(step_mother)
       load_plain_text_features(features)
       executor.lines_for_features = @options[:lines_for_features]
@@ -183,20 +172,60 @@ Defined profiles in cucumber.yml:
         arg
       end
     end
-    
+   
+    def cucumber_yml
+      return @cucumber_yml if @cucumber_yml
+      unless File.exist?('cucumber.yml')
+        raise(YmlLoadError,"cucumber.yml was not found.  Please refer to cucumber's documentaion on defining profiles in cucumber.yml.  You must define a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
+      end
+      
+      require 'yaml'
+      begin
+        @cucumber_yml = YAML::load(IO.read('cucumber.yml'))
+      rescue Exception => e
+        raise(YmlLoadError,"cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentaion on correct profile usage.\n")
+       end
+     
+      if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
+        raise(YmlLoadError,"cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentaion on correct profile usage.\n")
+      end
+
+      return @cucumber_yml
+    end 
+
+    def parse_args_from_profile(profile)
+      unless cucumber_yml.has_key?(profile)
+        return(exit_with_error <<-END_OF_ERROR)
+Could not find profile: '#{profile}'
+
+Defined profiles in cucumber.yml:
+  * #{cucumber_yml.keys.join("\n  * ")}
+        END_OF_ERROR
+      end
+
+      args_from_yml = cucumber_yml[profile] || ''
+
+      if !args_from_yml.is_a?(String)
+        exit_with_error "Profiles must be defined as a String.  The '#{profile}' profile was #{args_from_yml.inspect} (#{args_from_yml.class}).\n"
+      elsif args_from_yml =~ /^\s*$/
+        exit_with_error "The 'foo' profile in cucumber.yml was blank.  Please define the command line arguments for the 'foo' profile in cucumber.yml.\n"
+      else
+        parse_options!(args_from_yml.split(' '))
+      end
+      
+    rescue YmlLoadError => e
+      exit_with_error(e.message)
+    end
+
+
     # Requires files - typically step files and ruby feature files.
     def require_files
-      ARGV.clear # Shut up RSpec
+      @args.clear # Shut up RSpec
       require "cucumber/treetop_parser/feature_#{@options[:lang]}"
       require "cucumber/treetop_parser/feature_parser"
 
       verbose_log("Ruby files required:")
-      requires = @options[:require] || feature_dirs
-      libs = requires.map do |path|
-        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
-        File.directory?(path) ? Dir["#{path}/**/*.rb"] : path
-      end.flatten.uniq
-      libs.each do |lib|
+      files_to_require.each do |lib|
         begin
           require lib
           verbose_log("  * #{lib}")
@@ -207,6 +236,15 @@ Defined profiles in cucumber.yml:
       end
       verbose_log("\n")
     end
+    
+    def files_to_require
+      requires = @options[:require] || feature_dirs
+      files = requires.map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        File.directory?(path) ? Dir["#{path}/**/*.rb"] : path
+      end.flatten.uniq
+      files.sort { |a,b| (b =~ %r{/support/} || -1) <=>  (a =~ %r{/support/} || -1) }
+    end
 
     def feature_files
       potential_feature_files = @paths.map do |path|
@@ -280,14 +318,14 @@ Defined profiles in cucumber.yml:
   private
 
     def constantize(camel_cased_word)
-        names = camel_cased_word.split('::')
-        names.shift if names.empty? || names.first.empty?
- 
-        constant = Object
-        names.each do |name|
-          constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-        end
-        constant
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+      end
+      constant
     end
     
     def verbose_log(string)
@@ -303,6 +341,13 @@ Defined profiles in cucumber.yml:
       Kernel.exit 1
     end
 
+    def enable_diffing
+      if defined?(::Spec)
+        require 'spec/expectations/differs/default'
+        options = ::Spec::Runner::Options.new(nil, nil)
+        ::Spec::Expectations.differ = ::Spec::Expectations::Differs::Default.new(options)
+      end
+    end
   end
 end
 

data/lib/cucumber/core_ext/exception.rb

@@ -0,0 +1,20 @@
+class Exception
+  CUCUMBER_FILTER_PATTERNS = [
+    /vendor\/rails/, 
+    /vendor\/plugins\/cucumber/, 
+    /spec\/expectations/, 
+    /spec\/matchers/
+  ]
+
+  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|
+      CUCUMBER_FILTER_PATTERNS.detect{|p| line =~ p}
+    end.map { |line| line.strip }
+  end
+end

data/lib/cucumber/core_ext/string.rb

@@ -20,7 +20,7 @@ class String
     s
   end
 
-  if $CUCUMBER_JRUBY && $CUCUMBER_RAILS
+  if ($CUCUMBER_JRUBY && $CUCUMBER_RAILS)
     # Workaround for http://tinyurl.com/55uu3u 
     alias jlength length
   else

data/lib/cucumber/executor.rb

@@ -65,6 +65,10 @@ module Cucumber
       visit_scenario(scenario)
     end
 
+    def visit_scenario_outline(scenario)
+      visit_regular_scenario(scenario)
+    end
+
     def visit_scenario(scenario)
       if accept_scenario?(scenario)
         @executed_scenarios[scenario.name] = true
@@ -77,8 +81,6 @@ module Cucumber
       @pending = nil
 
       @world = create_world
-      @world.extend(Spec::Matchers) if defined?(Spec::Matchers)
-      define_step_call_methods(@world)
 
       formatters.scenario_executing(scenario)
       @before_scenario_procs.each{|p| p.call_in(@world, *[])}
@@ -104,6 +106,11 @@ module Cucumber
       visit_step(step)
     end
 
+    def visit_step_outline(step)
+      regexp, args, proc = step.regexp_args_proc(@step_mother)
+      formatters.step_traced(step, regexp, args)
+    end
+
     def visit_step(step)
       unless @pending || @error
         begin
@@ -112,6 +119,9 @@ module Cucumber
           step.execute_in(@world, regexp, args, proc)
           @after_step_procs.each{|p| p.call_in(@world, *[])}
           formatters.step_passed(step, regexp, args)
+        rescue ForcedPending => e
+          step.error = e
+          record_pending_step(step, regexp, args)
         rescue Pending
           record_pending_step(step, regexp, args)
         rescue => e
@@ -124,6 +134,9 @@ module Cucumber
           regexp, args, proc = step.regexp_args_proc(@step_mother)
           step.execute_in(@world, regexp, args, proc)
           formatters.step_skipped(step, regexp, args)
+        rescue ForcedPending => e
+          step.error = e
+          record_pending_step(step, regexp, args)
         rescue Pending
           record_pending_step(step, regexp, args)
         rescue Exception
@@ -137,22 +150,6 @@ module Cucumber
       formatters.step_pending(step, regexp, args)
     end
 
-    def define_step_call_methods(world)
-      world.instance_variable_set('@__executor', self)
-      world.instance_eval do
-        class << self
-          def run_step(name)
-            _, args, proc = @__executor.instance_variable_get(:@step_mother).regexp_args_proc(name)
-            proc.call_in(self, *args)
-          end
-
-          %w{given when then and but}.each do |keyword|
-            alias_method Cucumber.language[keyword], :run_step
-          end
-        end
-      end
-    end
-    
     def executing_unprepared_row_scenario?(scenario)
       accept_scenario?(scenario) && !@executed_scenarios[scenario.name]
     end
@@ -182,7 +179,27 @@ module Cucumber
       @world_procs.each do |world_proc|
         world = world_proc.call(world)
       end
+
+      world.extend(World::Pending)
+      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      define_step_call_methods(world)
       world
     end
+
+    def define_step_call_methods(world)
+      world.instance_variable_set('@__executor', self)
+      world.instance_eval do
+        class << self
+          def run_step(name)
+            _, args, proc = @__executor.instance_variable_get(:@step_mother).regexp_args_proc(name)
+            proc.call_in(self, *args)
+          end
+
+          %w{given when then and but}.each do |keyword|
+            alias_method Cucumber.language[keyword], :run_step
+          end
+        end
+      end
+    end
   end
 end

data/lib/cucumber/formatters/ansicolor.rb

@@ -1,5 +1,5 @@
 # Hack to work around Win32/Console, which bundles a licence-violating, outdated
-# copy of term/ansicolor that doesn't implement Term::ANSIColor#coloring=. 
+# 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/}
@@ -7,7 +7,7 @@ require 'term/ansicolor'
 
 if $CUCUMBER_WINDOWS_MRI
   begin
-    require 'Win32/Console/ANSI' 
+    require 'Win32/Console/ANSI'
   rescue LoadError
     STDERR.puts "You must gem install win32console to get coloured output on MRI/Windows"
     Term::ANSIColor.coloring = false
@@ -18,92 +18,83 @@ Term::ANSIColor.coloring = false if !STDOUT.tty? || ($CUCUMBER_WINDOWS && !$CUCU
 
 module Cucumber
   module Formatters
-    # Adds ANSI color support to formatters.
-    # You can define your own colours by defining CUCUMBER_COLORS in your shell. Example:
+    # 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>
     #
-    #   CUCUMBER_COLORS=pending=black,on_yellow:failed=dark,magenta:failed_param=bold,red
-    # 
-    # The string must be a series of key=value pairs where:
+    # The colours that you can change are:
     #
-    #   * Each key=value pair is separated by a colon (:)
-    #   * Each key must be one of:
-    #   ** passed
-    #   ** passed_param
-    #   ** failed
-    #   ** failed_param
-    #   ** skipped
-    #   ** skipped_param
-    #   ** pending
-    #   * Each value must be a comma-separated string composed of:
-    #   ** bold
-    #   ** dark
-    #   ** italic
-    #   ** underline
-    #   ** underscore
-    #   ** blink
-    #   ** rapid_blink
-    #   ** negative
-    #   ** concealed
-    #   ** strikethrough
-    #   ** black
-    #   ** red
-    #   ** green
-    #   ** yellow
-    #   ** blue
-    #   ** magenta
-    #   ** cyan
-    #   ** white
-    #   ** grey
-    #   ** on_black
-    #   ** on_red
-    #   ** on_green
-    #   ** on_yellow
-    #   ** on_blue
-    #   ** on_magenta
-    #   ** on_cyan
-    #   ** on_white
+    # * <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>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
-
-      # Params are underlined bold, except in windows, which doesn't support underline. Use non-bold colour.
-      param = PLATFORM =~ /mswin|mingw/ ? '' : 'underline,bold,'
+      include Term::ANSIColor
 
-      # Default aliases
-      ALIASES = {
-        :passed        => 'bold,green',
-        :passed_param  => "#{param}green",
-        :failed        => 'bold,red',
-        :failed_param  => "#{param}red",
-        :skipped       => 'bold,cyan',
-        :skipped_param => "#{param}cyan",
-        :pending       => 'bold,yellow', # No pending_param
-        :comment       => 'grey'
-      }
-      if ENV['CUCUMBER_COLORS']
-        ENV['CUCUMBER_COLORS'].split(':').each do |pair|
-          a = pair.split('=')
-          ALIASES[a[0].to_sym] = a[1]
-        end
-      end
-      
       # Not supported in Term::ANSIColor
       def grey(m)
         if ::Term::ANSIColor.coloring?
-          "\e[90m#{m}\e[0m" 
+          "\e[90m#{m}\e[0m"
         else
           m
         end
       end
-      
-      ALIASES.each do |m, color_string|
-        colors = color_string.split(",").reverse
-        define_method(m) do |*s|
-          clear + colors.inject(s[0]) do |memo, color|
-            s[0].nil? ? __send__(color) + memo.to_s : __send__(color, memo.to_s)
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_param/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'pending' => 'yellow',
+        'failed'  => 'red',
+        'passed'  => 'green',
+        '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
+end