cucumber 0.1.8 → 0.1.9

data/examples/i18n/ro/Rakefile

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__) + '/../../../lib')
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "--language ro"
+end

data/examples/i18n/ro/features/step_definitons/calculator_steps.rb

@@ -0,0 +1,22 @@
+require 'spec'
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'calculator'
+
+Before do
+  @calc = Calculator.new
+end
+
+After do
+end
+
+Given /introduc (\d+)/ do |n|
+  @calc.push n.to_i
+end
+
+When 'apas suma' do
+  @result = @calc.add
+end
+
+Then /rezultatul trebuie sa fie (\d*)/ do |result|
+  @result.should == result.to_i
+end

data/examples/i18n/ro/features/suma.feature

@@ -0,0 +1,10 @@
+Functionalitate: suma
+  Pentru a nu face erori stupide
+  Ca utilizator
+  Vreau sa stiu suma a doua numere
+
+  Scenariu: suma a doua numere
+    Daca introduc 5
+    Si apoi introduc 7
+    Cand apas suma
+    Atunci rezultatul trebuie sa fie 12

data/examples/i18n/ro/lib/calculator.rb

@@ -0,0 +1,11 @@
+class Calculator
+  def push(n)
+    @args ||= []
+    @args << n
+  end
+
+  def add
+    #@args[0] + @args[1]
+    @args.inject(0){|n,sum| sum+=n}
+  end
+end

data/examples/i18n/se/Rakefile

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__) + '/../../../lib')
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "--language se"
+end

data/examples/i18n/zh-CN/Rakefile

@@ -0,0 +1,6 @@
+$:.unshift(File.dirname(__FILE__) + '/../../../lib')
+require 'cucumber/rake/task'
+
+Cucumber::Rake::Task.new do |t|
+  t.cucumber_opts = "--language zh-CN"
+end

data/examples/watir/features/search.feature

@@ -5,5 +5,5 @@ Feature: Search
 
   Scenario: Find what I'm looking for
     Given I am on the Google search page
-    When I search for "rspec"
-    Then I should see a link to "RSpec-1.1.5: Overview":http://rspec.info/
+    When I search for "cucumber github"
+    Then I should see a link to "Ruby on Rails — cucumber — GitHub":http://github.com/aslakhellesoy/cucumber/wikis/ruby-on-rails

data/gem_tasks/treetop.rake

@@ -25,15 +25,6 @@ class FeatureCompiler
     end
     sh "#{@tt} #{grammar_file}"
     FileUtils.rm(grammar_file)
-    
-    # Change code so it isn't part of RDoc
-    lines = IO.read(ruby_file).split("\n")
-    lines.each do |line|
-      if line =~ /\s*(def|class|module)/
-        line << " #:nodoc:"
-      end
-    end
-    File.open(ruby_file, 'wb'){|io| io.write(lines.join("\n"))}
   end
 end
 
@@ -43,6 +34,7 @@ namespace :treetop do
     FeatureCompiler.new.compile_all
   end
 
+  desc 'Compile the English grammar'
   task :compile_en do
     FeatureCompiler.new.compile('en')
   end

data/lib/autotest/cucumber.rb

@@ -0,0 +1,6 @@
+require 'autotest'
+require 'autotest/cucumber_mixin'
+
+class Autotest::Cucumber < Autotest
+  include CucumberMixin
+end

data/lib/autotest/cucumber_mixin.rb

@@ -0,0 +1,109 @@
+require 'autotest'
+require 'tempfile'
+
+module Autotest::CucumberMixin
+  def self.included(receiver)
+    receiver::ALL_HOOKS << [:run_features, :ran_features]
+  end
+  
+  attr_accessor :scenarios_to_run
+  
+  def initialize
+    super
+    reset_features
+  end
+  
+  def run
+    hook :initialize
+    reset
+    reset_features
+    add_sigint_handler
+
+    self.last_mtime = Time.now if $f
+
+    loop do # ^c handler
+      begin
+        get_to_green
+        if self.tainted then
+          rerun_all_tests
+          rerun_all_features if all_good
+        else
+          hook :all_good
+        end
+        wait_for_changes
+        # Once tests and features are green, reset features every
+        # time a file is changed to see if anything breaks.
+        reset_features
+      rescue Interrupt
+        break if self.wants_to_quit
+        reset
+        reset_features
+      end
+    end
+    hook :quit
+  end
+  
+  def all_features_good
+    scenarios_to_run == []
+  end
+  
+  def get_to_green
+    begin
+      super
+      run_features
+      wait_for_changes unless all_features_good
+    end until all_features_good
+  end
+  
+  def rerun_all_features
+    reset_features
+    run_features
+  end
+  
+  def reset_features
+    self.scenarios_to_run = :all
+  end
+    
+  def run_features
+    hook :run_features
+    Tempfile.open('autotest-cucumber') do |dirty_scenarios_file|
+      cmd = self.make_cucumber_cmd self.scenarios_to_run, dirty_scenarios_file.path
+      return if cmd.empty?
+      puts cmd unless $q
+      system cmd
+      self.scenarios_to_run = dirty_scenarios_file.readlines.map { |l| l.chomp }
+      self.tainted = true unless self.scenarios_to_run == []
+    end
+    hook :ran_features
+  end
+  
+  def make_cucumber_cmd(scenarios_to_run, dirty_scenarios_filename)
+    return '' if scenarios_to_run == []
+    
+    profiles = YAML.load_file("cucumber.yml").keys rescue []
+    
+    profile ||= "autotest-all" if profiles.include?("autotest-all") and scenarios_to_run == :all
+    profile ||= "autotest"     if profiles.include?("autotest")
+    profile ||= nil
+    
+    if profile
+      args = ["--profile", profile]
+    else
+      args = %w{features --format} << (scenarios_to_run == :all ? "progress" : "pretty")
+    end
+    args += %w{--format autotest --out} << dirty_scenarios_filename
+    args = args.join(' ')
+    
+    if scenarios_to_run == :all
+      scenario_args = nil
+    else
+      scenario_args = scenarios_to_run.map { |s| "-s '#{s}'" }.join(' ')
+    end
+    
+    return "#{cucumber} #{args} #{scenario_args}"
+  end
+  
+  def cucumber
+    File.exist?("script/cucumber") ? "script/cucumber" : "cucumber"
+  end
+end

data/lib/autotest/cucumber_rails.rb

@@ -0,0 +1,6 @@
+require 'autotest/rails'
+require 'autotest/cucumber_mixin'
+
+class Autotest::CucumberRails < Autotest::Rails
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rails_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rails_rspec'
+
+class Autotest::CucumberRailsRspec < Autotest::RailsRspec
+  include CucumberMixin
+end

data/lib/autotest/cucumber_rspec.rb

@@ -0,0 +1,6 @@
+require 'autotest/cucumber_mixin'
+require 'autotest/rspec'
+
+class Autotest::CucumberRspec < Autotest::Rspec
+  include CucumberMixin
+end

data/lib/autotest/discover.rb

@@ -0,0 +1,9 @@
+Autotest.add_discovery do
+  if File.directory?('features')
+    if ENV['AUTOFEATURE'] == 'true'
+      "cucumber"
+    else
+      puts "(Not running features.  To run features in autotest, set AUTOFEATURE=true.)"
+    end
+  end
+end

data/lib/cucumber.rb

@@ -12,6 +12,10 @@ require 'cucumber/step_mother'
 require 'cucumber/formatters'
 require 'cucumber/treetop_parser/feature_parser'
 require 'cucumber/cli'
+require 'cucumber/broadcaster'
+
+$KCODE='u'
+require 'jcode'
 
 module Cucumber
   LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/cucumber/languages.yml')

data/lib/cucumber/broadcaster.rb

@@ -0,0 +1,20 @@
+module Cucumber
+  class Broadcaster
+
+    def initialize(receivers = [])
+      @receivers = receivers
+    end
+
+    def register(receiver)
+      @receivers << receiver
+    end
+
+    def method_missing(method_name, *args)
+      @receivers.each  do |receiver|
+        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
+
+  end
+end

data/lib/cucumber/cli.rb

@@ -5,12 +5,12 @@ module Cucumber
   class CLI
     class << self
       attr_writer :step_mother, :executor, :features
-    
+
       def execute
         @execute_called = true
         parse(ARGV).execute!(@step_mother, @executor, @features)
       end
-      
+
       def execute_called?
         @execute_called
       end
@@ -21,52 +21,87 @@ module Cucumber
         cli
       end
     end
-    
+
     attr_reader :options
-    FORMATS = %w{pretty profile progress html}
+    FORMATS = %w{pretty profile progress html autotest}
+    DEFAULT_FORMAT = 'pretty'
 
-    def initialize
+    def initialize(out_stream = STDOUT, error_stream = STDERR)
+      @out_stream = out_stream
+      @error_stream = error_stream
       @paths = []
+      @options = {
+        :require => nil,
+        :lang    => 'en',
+        :dry_run => false,
+        :source  => true,
+        :snippets => true,
+        :formats => {},
+        :excludes => [],
+        :scenario_names => nil
+      }
+      @active_format = DEFAULT_FORMAT
     end
 
     def parse_options!(args)
       return parse_args_from_profile('default') if args.empty?
       args.extend(OptionParser::Arguable)
 
-      @options ||= { 
-        :require => nil, 
-        :lang    => 'en', 
-        :format  => 'pretty', 
-        :dry_run => false, 
-        :source  => true,
-        :out     => STDOUT
-      }
       args.options do |opts|
         opts.banner = "Usage: cucumber [options] FILES|DIRS"
         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") do |v|
+          "are siblings or below the features will be autorequired",
+          "This option can be specified multiple times.") do |v|
           @options[:require] ||= []
           @options[:require] << v
         end
         opts.on("-l LINE", "--line LINE", "Only execute the scenario at the given line") do |v|
           @options[:line] = v
         end
+        opts.on("-s SCENARIO", "--scenario SCENARIO", "Only execute the scenario with the given name.",
+                                                      "If this option is given more than once, run all",
+                                                      "the specified scenarios.") do |v|
+          @options[:scenario_names] ||= []
+          @options[:scenario_names] << v
+        end
         opts.on("-a 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
         end
-        opts.on("-f FORMAT", "--format FORMAT", "How to format features (Default: #{@options[:format]})",
-          "Available formats: #{FORMATS.join(", ")}") do |v|
-          unless FORMATS.index(v) 
-            STDERR.puts "Invalid format: #{v}\n"
-            STDERR.puts opts.help
+        opts.on("-f FORMAT", "--format FORMAT", "How to format features (Default: #{DEFAULT_FORMAT})",
+          "Available formats: #{FORMATS.join(", ")}",
+          "This option can be specified multiple times.") do |v|
+          unless FORMATS.index(v)
+            @error_stream.puts "Invalid format: #{v}\n"
+            @error_stream.puts opts.help
             exit 1
           end
-          @options[:format] = v
+          @options[:formats][v] ||= []
+          @options[:formats][v] << @out_stream
+          @active_format = v
+        end
+        opts.on("-o", "--out FILE", "Write output to a file instead of @out_stream.",
+          "This option can be specified multiple times, and applies to the previously",
+          "specified --format.") do |v|
+          @options[:formats][@active_format] ||= []
+          if @options[:formats][@active_format].last == @out_stream
+            @options[:formats][@active_format][-1] = File.open(v, 'w')
+          else
+            @options[:formats][@active_format] << File.open(v, 'w')
+          end
+        end
+        opts.on("-c", "--[no-]color", "Use ANSI color in the output, if formatters use it.  If",
+                                      "these options are given multiple times, the last one is",
+                                      "used.  If neither --color or --no-color is given cucumber",
+                                      "decides based on your platform and the output destination") do |v|
+          @options[:color] = v
         end
-        opts.on("-p=PROFILE", "--profile=PROFILE", "Pull commandline arguments from cucumber.yml.") do |v|
+        opts.on("-e", "--exclude PATTERN", "Don't run features matching a pattern") do |v|
+          @options[:excludes] << v
+        end
+        opts.on("-p", "--profile PROFILE", "Pull commandline arguments from cucumber.yml.") do |v|
           parse_args_from_profile(v)
         end
         opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.") do
@@ -75,8 +110,12 @@ module Cucumber
         opts.on("-n", "--no-source", "Don't show the file and line of the step definition with the steps.") do
           @options[:source] = false
         end
-        opts.on("-o", "--out=FILE", "Write output to a file instead of STDOUT.") do |v|
-          @options[:out] = File.open(v, 'w')
+        opts.on("-i", "--no-snippets", "Don't show the snippets for pending steps") do
+          @options[:snippets] = false
+        end
+        opts.on("-q", "--quiet", "Don't show any development aid information") do
+          @options[:snippets] = false
+          @options[:source] = false
         end
         opts.on_tail("--version", "Show version") do
           puts VERSION::STRING
@@ -87,31 +126,52 @@ module Cucumber
           exit
         end
       end.parse!
-      
+
+      if @options[:formats].empty?
+        @options[:formats][DEFAULT_FORMAT] = [@out_stream]
+      end
+
       # Whatever is left after option parsing is the FILE arguments
       @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]
-      raise "Expected to find a String, got #{args_from_yml.inspect}. cucumber.yml:\n#{cucumber_yml}" unless String === args_from_yml
-      parse_options!(args_from_yml.split(' '))
+      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])
-      executor.formatter = formatter(step_mother)
+      executor.formatters = build_formatter_broadcaster(step_mother)
       require_files
       load_plain_text_features(features)
       executor.line = @options[:line].to_i if @options[:line]
+      executor.scenario_names = @options[:scenario_names] if @options[:scenario_names]
       executor.visit_features(features)
       exit 1 if executor.failed
     end
-    
-  private
-    
+
+    private
+
     # Requires files - typically step files and ruby feature files.
     def require_files
       ARGV.clear # Shut up RSpec
@@ -134,16 +194,25 @@ module Cucumber
     end
 
     def feature_files
-      @paths.map do |path|
+      potential_feature_files = @paths.map do |path|
         path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        path = path.chomp('/')
         File.directory?(path) ? Dir["#{path}/**/*.feature"] : path
       end.flatten.uniq
+
+      @options[:excludes].each do |exclude|
+        potential_feature_files.reject! do |path|
+          path =~ /#{Regexp.escape(exclude)}/
+        end
+      end
+
+      potential_feature_files
     end
-    
+
     def feature_dirs
       feature_files.map{|f| File.directory?(f) ? f : File.dirname(f)}.uniq
     end
-    
+
     def load_plain_text_features(features)
       parser = TreetopParser::FeatureParser.new
 
@@ -151,22 +220,44 @@ module Cucumber
         features << parser.parse_feature(f)
       end
     end
-    
-    def formatter(step_mother)
-      case @options[:format]
-      when 'pretty'
-        Formatters::PrettyFormatter.new(@options[:out], step_mother, @options)
-      when 'progress'
-        Formatters::ProgressFormatter.new(@options[:out])
-       when 'profile'
-        Formatters::ProfileFormatter.new(@options[:out], step_mother)
-      when 'html'
-        Formatters::HtmlFormatter.new(@options[:out], step_mother)
-      else
-        raise "Unknown formatter: #{@options[:format]}"
+
+    def build_formatter_broadcaster(step_mother)
+      formatter_broadcaster = Broadcaster.new
+      @options[:formats].each do |format, output_list|
+        output_broadcaster = build_output_broadcaster(output_list)
+        case format
+        when 'pretty'
+          formatter_broadcaster.register(Formatters::PrettyFormatter.new(output_broadcaster, step_mother, @options))
+        when 'progress'
+          formatter_broadcaster.register(Formatters::ProgressFormatter.new(output_broadcaster))
+        when 'profile'
+          formatter_broadcaster.register(Formatters::ProfileFormatter.new(output_broadcaster, step_mother))
+        when 'html'
+          formatter_broadcaster.register(Formatters::HtmlFormatter.new(output_broadcaster, step_mother))
+        when 'autotest'
+          formatter_broadcaster.register(Formatters::AutotestFormatter.new(output_broadcaster))
+        else
+          raise "Unknown formatter: #{@options[:format]}"
+        end
       end
+      formatter_broadcaster
+    end
+
+    def build_output_broadcaster(output_list)
+      output_broadcaster = Broadcaster.new
+      output_list.each do |output|
+        output_broadcaster.register(output)
+      end
+      output_broadcaster
     end
     
+  private
+
+    def exit_with_error(error_message)
+      @error_stream << error_message
+      Kernel.exit 1
+    end
+
   end
 end