kosmas58-cucumber 0.2.3.3 → 0.3.9.4

data/lib/cucumber/rails/world.rb

@@ -7,7 +7,14 @@ else
   require 'action_controller/test_process'
   require 'action_controller/integration'
 end
-require 'test/unit/testresult'
+
+begin
+  require 'test/unit/testresult'
+rescue LoadError => e
+  e.message << "\nYou must gem install test-unit. For more info see https://rspec.lighthouseapp.com/projects/16211/tickets/292"
+  e.message << "\nAlso make sure you have rack 1.0.0 or higher."
+  raise e
+end
 
 # So that Test::Unit doesn't launch at the end - makes it think it has already been run.
 Test::Unit.run = true if Test::Unit.respond_to?(:run=)
@@ -30,6 +37,11 @@ module Cucumber #:nodoc:
     end
 
     def self.use_transactional_fixtures
+
+      unless ::Rails.configuration.cache_classes
+        warn "WARNING: You have set Rails' config.cache_classes to false (most likely in config/environments/test.rb).  This setting is known to break Cucumber's use_transactional_fixtures method. Set config.cache_classes to true if you want to use transactional fixtures.  For more information see https://rspec.lighthouseapp.com/projects/16211/tickets/165."
+      end
+
       World.use_transactional_fixtures = true
       if defined?(ActiveRecord::Base)
         $__cucumber_toplevel.Before do
@@ -56,13 +68,26 @@ module Cucumber #:nodoc:
 
     def self.bypass_rescue
       ActionController::Base.class_eval do
+        alias_method :rescue_action_without_bypass, :rescue_action
+
         def rescue_action(exception)
           raise exception
         end
       end
-      ActionController::Dispatcher.class_eval do
-        def self.failsafe_response(output, status, exception = nil)
-          raise exception
+
+      begin
+        ActionController::Failsafe.class_eval do
+          alias_method :failsafe_response_without_bypass, :failsafe_response
+        
+          def failsafe_response(exception)
+            raise exception
+          end
+        end
+      rescue NameError # Failsafe was introduced in Rails 2.3.2
+        ActionController::Dispatcher.class_eval do
+          def self.failsafe_response(output, status, exception = nil)
+            raise exception
+          end
         end
       end
     end

data/lib/cucumber/rake/task.rb

@@ -14,7 +14,7 @@ module Cucumber
     # To further configure the task, you can pass a block:
     #
     #   Cucumber::Rake::Task.new do |t|
-    #     t.cucumber_opts = "--format progress"
+    #     t.cucumber_opts = %w{--format progress}
     #   end
     #
     # This task can also be configured to be run with RCov:
@@ -25,46 +25,139 @@ module Cucumber
     # 
     # See the attributes for additional configuration possibilities.
     class Task
-      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..') # :nodoc:
+      class InProcessCucumberRunner #:nodoc:
+        attr_reader :args
+        
+        def initialize(libs, cucumber_opts, feature_files)
+          raise "libs must be an Array when running in-process" unless Array === libs
+          libs.reverse.each{|lib| $LOAD_PATH.unshift(lib)}
+          @args = (
+            cucumber_opts + 
+            feature_files
+          ).flatten.compact
+        end
+        
+        def run
+          require 'cucumber/cli/main'
+          failure = Cucumber::Cli::Main.execute(args)
+          raise "Cucumber failed" if failure
+        end
+      end
+      
+      class ForkedCucumberRunner #:nodoc:
+        attr_reader :args
+        
+        def initialize(libs, cucumber_bin, cucumber_opts, feature_files)
+          @args = (
+            ['-I'] + load_path(libs) + 
+            quoted_binary(cucumber_bin) + 
+            cucumber_opts + 
+            feature_files
+          ).flatten
+        end
+
+        def load_path(libs)
+          ['"%s"' % libs.join(File::PATH_SEPARATOR)]
+        end
+
+        def quoted_binary(cucumber_bin)
+          ['"%s"' % cucumber_bin]
+        end
+
+        def run
+          ruby(args.join(" ")) # ruby(*args) is broken on Windows
+        end
+      end
+
+      class RCovCucumberRunner < ForkedCucumberRunner #:nodoc:
+        def initialize(libs, cucumber_bin, cucumber_opts, feature_files, rcov_opts)
+          @args = (
+            ['-I'] + load_path(libs) + 
+            ['-S', 'rcov'] + rcov_opts +
+            quoted_binary(cucumber_bin) + 
+            ['--'] + 
+            cucumber_opts + 
+            feature_files
+          ).flatten
+        end
+      end
+
+      LIB = File.expand_path(File.dirname(__FILE__) + '/../..') # :nodoc:
+
+      # TODO: remove depreated accessors for 0.4.0
+      def self.deprecate_accessor(attribute) # :nodoc:
+        attr_reader attribute
+        class_eval <<-EOF, __FILE__, __LINE__ + 1
+          def #{attribute}=(value)
+            @#{attribute} = value
+            warn("Cucumber::Rake::Task##{attribute} is deprecated and will be removed in 0.4.0.  Please use profiles for complex settings: http://wiki.github.com/aslakhellesoy/cucumber/using-rake#profiles")
+          end
+        EOF
+      end
 
       # Directories to add to the Ruby $LOAD_PATH
       attr_accessor :libs
+
       # Name of the cucumber binary to use for running features. Defaults to Cucumber::BINARY
       attr_accessor :binary
+
       # Array of paths to specific step definition files to use
-      attr_accessor :step_list
+      deprecate_accessor :step_list
+
       # File pattern for finding step definitions. Defaults to 
       # 'features/**/*.rb'.
-      attr_accessor :step_pattern
+      deprecate_accessor :step_pattern
+
       # Array of paths to specific features to run. 
-      attr_accessor :feature_list
+      deprecate_accessor :feature_list
+
       # File pattern for finding features to run. Defaults to 
-      # 'features/**/*.feature'. Can be overriden by the FEATURE environment variable.
-      attr_accessor :feature_pattern
+      # 'features/**/*.feature'. Can be overridden by the FEATURE environment variable.
+      deprecate_accessor :feature_pattern
+
       # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
+      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
       attr_accessor :cucumber_opts
-      # Run cucumber with RCov?
+      def cucumber_opts=(opts) #:nodoc:
+        @cucumber_opts = String === opts ? opts.split(' ') : opts
+      end
+
+      # Run cucumber with RCov? Defaults to false. If you set this to
+      # true, +fork+ is implicit.
       attr_accessor :rcov
-      # Extra options to pass to rcov
+
+      # Extra options to pass to rcov.
+      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
       attr_accessor :rcov_opts
-      # Extra options for multi language support
-      attr_accessor :language
+      def rcov_opts=(opts) #:nodoc:
+        @rcov_opts = String === opts ? opts.split(' ') : opts
+      end
 
-      # Define a Rake
+      # Whether or not to fork a new ruby interpreter. Defaults to true.
+      attr_accessor :fork
+
+      # Define what profile to be used.  When used with cucumber_opts it is simply appended to it. Will be ignored when CUCUMBER_OPTS is used.
+      attr_accessor :profile
+      def profile=(profile) #:nodoc:
+        @profile = profile
+        unless feature_list
+          # TODO: remove once we completely remove these from the rake task.
+          @step_list = []
+          @feature_list = [] # Don't use accessor to avoid deprecation warning.
+        end
+      end
+
+      # Define Cucumber Rake task
       def initialize(task_name = "features", desc = "Run Features with Cucumber")
         @task_name, @desc = task_name, desc
+        @fork = true
         @libs = ['lib']
         @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
 
         yield self if block_given?
 
-        if language
-          @feature_pattern = "features/#{language}/*.feature"
-          @step_pattern    = "features/#{language}/step_definitions/*.rb"
-        else
-          @feature_pattern = "features/**/*.feature" if feature_pattern.nil? && feature_list.nil?
-          @step_pattern    = "features/**/*.rb"      if step_pattern.nil? && step_list.nil?
-        end
+        @feature_pattern = "features/**/*.feature" if feature_pattern.nil? && feature_list.nil?
+        @step_pattern    = "features/**/*.rb"      if step_pattern.nil? && step_list.nil?
 
         @binary = binary.nil? ? Cucumber::BINARY : File.expand_path(binary)
         @libs.insert(0, LIB) if binary == Cucumber::BINARY
@@ -75,28 +168,23 @@ module Cucumber
       def define_task # :nodoc:
         desc @desc
         task @task_name do
-          ruby(arguments_for_ruby_execution.join(" ")) # ruby(*args) is broken on Windows
+          runner.run
         end
       end
 
-      def arguments_for_ruby_execution(task_args = nil) # :nodoc:
-        lib_args     = ['"%s"' % libs.join(File::PATH_SEPARATOR)]
-        cucumber_bin = ['"%s"' % binary]
-        cuc_opts     = [(ENV['CUCUMBER_OPTS'] || cucumber_opts)]
-
-        step_files(task_args).each do |step_file|
-          cuc_opts << '--require'
-          cuc_opts << step_file
-        end
-
-        if rcov
-          args = (['-I'] + lib_args + ['-S', 'rcov'] + rcov_opts +
-            cucumber_bin + ['--'] + cuc_opts + feature_files(task_args)).flatten
+      def runner(task_args = nil) # :nodoc:
+        cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
+        if(@rcov)
+          RCovCucumberRunner.new(libs, binary, cucumber_opts, feature_files(task_args), rcov_opts)
+        elsif(@fork)
+          ForkedCucumberRunner.new(libs, binary, cucumber_opts, feature_files(task_args))
         else
-          args = (['-I'] + lib_args + cucumber_bin + cuc_opts + feature_files(task_args)).flatten
+          InProcessCucumberRunner.new(libs, cucumber_opts, feature_files(task_args))
         end
+      end
 
-        args
+      def cucumber_opts_with_profile # :nodoc:
+        @profile ? [cucumber_opts, '--profile', @profile] : cucumber_opts
       end
 
       def feature_files(task_args = nil) # :nodoc:
@@ -131,7 +219,7 @@ module Cucumber
       def define_task # :nodoc:
         desc @desc
         task @task_name, :feature_name do |t, args|
-          ruby(arguments_for_ruby_execution(args).join(" ")) # ruby(*args) is broken on Windows
+          runner(args).run
         end
       end
 
@@ -142,4 +230,4 @@ module Cucumber
     end
 
   end
-end
+end

data/lib/cucumber/rspec_neuter.rb

@@ -0,0 +1,23 @@
+require 'optparse'
+
+module Spec
+  module Runner
+    # Neuters RSpec's option parser.
+    # (RSpec's option parser tries to parse ARGV, which
+    # will fail when running cucumber)
+    class OptionParser < ::OptionParser
+      NEUTERED_RSPEC = Object.new
+      def NEUTERED_RSPEC.method_missing(m, *args); self; end
+      
+      def self.method_added(m)
+        unless @__neutering_rspec
+          @__neutering_rspec = true
+          define_method(m) do |*a|
+            NEUTERED_RSPEC
+          end
+          @__neutering_rspec = false
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/step_definition.rb

@@ -70,9 +70,12 @@ module Cucumber
       end
       block_args << multiline_arg_class.default_arg_name unless multiline_arg_class.nil?
       block_arg_string = block_args.empty? ? "" : " |#{block_args.join(", ")}|"
-      multiline_class_string = multiline_arg_class ? "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  " : ""
+      multiline_class_comment = ""
+      if(multiline_arg_class == Ast::Table)
+        multiline_class_comment = "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  "
+      end
 
-      "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  #{multiline_class_string}pending\nend"
+      "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  #{multiline_class_comment}pending\nend"
     end
 
     class MissingProc < StandardError

data/lib/cucumber/step_match.rb

@@ -1,12 +1,15 @@
 module Cucumber
   class StepMatch
-    attr_reader :step_definition
-    attr_reader :args
-    
+    attr_reader :step_definition, :args
+
     def initialize(step_definition, step_name, formatted_step_name, args)
       @step_definition, @step_name, @formatted_step_name, @args = step_definition, step_name, formatted_step_name, args
     end
-    
+
+    def name
+      @formatted_step_name
+    end
+
     def invoke(world, multiline_arg)
       all_args = @args.dup
       all_args << multiline_arg if multiline_arg
@@ -33,12 +36,13 @@ module Cucumber
   class NoStepMatch
     attr_reader :step_definition
 
-    def initialize(step)
+    def initialize(step, name)
       @step = step
+      @name = name
     end
     
     def format_args(format)
-      @step.name
+      @name
     end
 
     def file_colon_line

data/lib/cucumber/step_mother.rb

@@ -57,7 +57,8 @@ module Cucumber
       message << "in 2 places:\n\n"
       message << first_proc.backtrace_line('World') << "\n"
       message << second_proc.backtrace_line('World') << "\n\n"
-      message << "Use Ruby modules instead to extend your worlds. See the #World RDoc.\n\n"
+      message << "Use Ruby modules instead to extend your worlds. See the Cucumber::StepMother#World RDoc\n"
+      message << "or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.\n\n"
       super(message)
     end
   end
@@ -67,6 +68,29 @@ module Cucumber
   # so #register_step_definition (and more interestingly - its aliases) are
   # available from the top-level.
   module StepMother
+    class Hook
+      def initialize(tag_names, proc)
+        @tag_names = tag_names.map{|tag| Ast::Tags.strip_prefix(tag)}
+        @proc = proc
+      end
+
+      def matches_tag_names?(tag_names)
+        @tag_names.empty? || (@tag_names & tag_names).any?
+      end
+
+      def execute_in(world, scenario, location, exception_fails_scenario = true)
+        begin
+          world.cucumber_instance_exec(false, location, scenario, &@proc)
+        rescue Exception => exception
+          if exception_fails_scenario
+            scenario.fail!(exception)
+          else
+            raise
+          end
+        end
+      end
+    end
+
     class << self
       def alias_adverb(adverb)
         adverb = adverb.gsub(/\s/, '')
@@ -76,6 +100,10 @@ module Cucumber
 
     attr_writer :snippet_generator, :options, :visitor
 
+    def options
+      @options ||= {}
+    end
+
     def step_visited(step)
       steps << step unless steps.index(step)
     end
@@ -89,8 +117,13 @@ module Cucumber
       end
     end
 
-    def scenarios
+    def scenarios(status = nil)
       @scenarios ||= []
+      if(status)
+        @scenarios.select{|scenario| scenario.status == status}
+      else
+        @scenarios
+      end
     end
 
     # Registers a new StepDefinition. This method is aliased
@@ -114,12 +147,30 @@ module Cucumber
 
     # Registers a Before proc. You can call this method as many times as you
     # want (typically from ruby scripts under <tt>support</tt>).
-    def Before(&proc)
-      (@before_procs ||= []) << proc
+    def Before(*tag_names, &proc)
+      register_hook(:before, tag_names, proc)
+    end
+
+    def After(*tag_names, &proc)
+      register_hook(:after, tag_names, proc)
     end
 
-    def After(&proc)
-      (@after_procs ||= []).unshift(proc)
+    def AfterStep(*tag_names, &proc)
+      register_hook(:after_step, tag_names, proc)
+    end
+
+    def register_hook(phase, tags, proc)
+      hook = Hook.new(tags, proc)
+      hooks[phase] << hook
+      hook
+    end
+
+    def hooks
+      @hooks ||= Hash.new {|hash, phase| hash[phase] = []}
+    end
+
+    def hooks_for(phase, scenario)
+      hooks[phase].select{|hook| scenario.accept_hook?(hook)}
     end
 
     # Registers any number of +world_modules+ (Ruby Modules) and/or a Proc.
@@ -188,6 +239,13 @@ module Cucumber
       end
     end
     
+    def clear!
+      step_definitions.clear
+      hooks.clear
+      steps.clear
+      scenarios.clear
+    end
+
     def step_definitions
       @step_definitions ||= []
     end
@@ -197,30 +255,39 @@ module Cucumber
     end
 
     def before_and_after(scenario, skip=false)
-      unless current_world || skip
+      before(scenario) unless skip
+      @current_scenario = scenario
+      yield scenario
+      @current_scenario = nil
+      after(scenario) unless skip
+      scenario_visited(scenario)
+    end
+    
+    def before(scenario)
+      unless current_world
         new_world!
         execute_before(scenario)
       end
-      if block_given?
-        yield
-        execute_after(scenario) unless skip
-        nil_world!
-        scenario_visited(scenario)
-      end
     end
-
+    
+    def after(scenario)
+      execute_after(scenario)
+      nil_world!
+    end
+    
+    def after_step
+      execute_after_step(@current_scenario)
+    end
+    
     private
 
     def max_step_definition_length
       @max_step_definition_length ||= step_definitions.map{|step_definition| step_definition.text_length}.max
     end
 
-    def options
-      @options || {}
-    end
-
     # Creates a new world instance
     def new_world!
+      return if options[:dry_run]
       create_world!
       extend_world
       connect_world
@@ -268,23 +335,28 @@ module Cucumber
     end
 
     def execute_before(scenario)
-      (@before_procs ||= []).each do |proc|
-        @current_world.cucumber_instance_exec(false, 'Before', scenario, &proc)
+      return if options[:dry_run]
+      hooks_for(:before, scenario).each do |hook|
+        hook.execute_in(@current_world, scenario, 'Before')
       end
     end
 
     def execute_after(scenario)
-      (@after_procs ||= []).each do |proc|
-        @current_world.cucumber_instance_exec(false, 'After', scenario, &proc)
+      return if options[:dry_run]
+      hooks_for(:after, scenario).each do |hook|
+        hook.execute_in(@current_world, scenario, 'After')
       end
     end
 
-    def scenario_visited(scenario)
-      scenarios << scenario unless scenarios.index(scenario)
+    def execute_after_step(scenario)
+      return if options[:dry_run]
+      hooks_for(:after_step, scenario).each do |hook|
+        hook.execute_in(@current_world, scenario, 'AfterStep', false)
+      end
     end
 
-    def options
-      @options || {}
+    def scenario_visited(scenario)
+      scenarios << scenario unless scenarios.index(scenario)
     end
   end
 end

data/lib/cucumber/version.rb

@@ -1,9 +1,9 @@
 module Cucumber #:nodoc:
   class VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 2
-    TINY  = 3
-    PATCH = 3 # Set to nil for official release
+    MINOR = 3
+    TINY  = 9
+    PATCH = 4 # Set to nil for official release
 
     STRING = [MAJOR, MINOR, TINY, PATCH].compact.join('.')
   end

data/lib/cucumber/world.rb

@@ -16,7 +16,7 @@ module Cucumber
         step_match.invoke(self, multiline_argument)
       rescue Exception => e
         e.nested! if Undefined === e
-        @__cucumber_current_step.exception = e
+        @__cucumber_current_step.exception = e if @__cucumber_current_step
         raise e
       end
     end
@@ -50,4 +50,4 @@ module Cucumber
       end
     end
   end
-end
+end

data/lib/cucumber.rb

@@ -14,6 +14,7 @@ module Cucumber
   KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
   
   class << self
+    # The currently active language
     attr_reader :lang
     
     def load_language(lang) #:nodoc:
@@ -38,10 +39,14 @@ module Cucumber
     def keyword_hash(lang=@lang)
       LANGUAGES[lang]
     end
+
+    def scenario_keyword
+      keyword_hash['scenario'].split('|')[0] + ':'
+    end
     
     def alias_step_definitions(lang) #:nodoc:
-      keywords = %w{given when then and but}.map{|keyword| keyword_hash(lang)[keyword]}
-      alias_steps(keywords)
+      keywords = %w{given when then and but}.map{|keyword| keyword_hash(lang)[keyword].split('|')}
+      alias_steps(keywords.flatten)
     end
     
     # Sets up additional method aliases for Given, When and Then.

data/rails_generators/cucumber/USAGE

@@ -7,8 +7,5 @@ Description:
     Also see the feature generator, which you can use to generate skeletons
     for new features.
     
-    If you set the language option, then a subdirectory features/[language] will be generated instead. 
-    Now your are able to use features in different languages.
-    
 Examples:
     `./script/generate cucumber`