dwaite-cucumber 0.3.101

data/lib/cucumber/rails/world.rb

@@ -0,0 +1,100 @@
+# Based on code from Brian Takita, Yurii Rashkovskii and Ben Mabey
+# Adapted by Aslak Hellesøy
+
+if defined?(ActiveRecord::Base)
+  require 'test_help' 
+else
+  require 'action_controller/test_process'
+  require 'action_controller/integration'
+end
+
+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=)
+
+$__cucumber_toplevel = self
+
+module Cucumber #:nodoc:
+  module Rails
+    # All scenarios will execute in the context of a new instance of Cucumber::Rails:World if this file 
+    # is loaded. This gives Step Definitions access to all the methods from Rails' ActionController::IntegrationTest
+    class World < ActionController::IntegrationTest
+      if defined?(ActiveRecord::Base)
+        self.use_transactional_fixtures = false
+      else
+        def self.fixture_table_names; []; end # Workaround for projects that don't use ActiveRecord
+      end
+
+      def initialize #:nodoc:
+        @_result = Test::Unit::TestResult.new
+      end
+    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
+          @__cucumber_ar_connection = ActiveRecord::Base.connection
+          if @__cucumber_ar_connection.respond_to?(:increment_open_transactions)
+            @__cucumber_ar_connection.increment_open_transactions
+          else
+            ActiveRecord::Base.__send__(:increment_open_transactions)
+          end
+          @__cucumber_ar_connection.begin_db_transaction
+          ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
+        end
+        
+        $__cucumber_toplevel.After do
+          @__cucumber_ar_connection.rollback_db_transaction
+          if @__cucumber_ar_connection.respond_to?(:decrement_open_transactions)
+            @__cucumber_ar_connection.decrement_open_transactions
+          else
+            ActiveRecord::Base.__send__(:decrement_open_transactions)
+          end
+        end
+      end
+    end
+
+    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
+
+      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
+  end
+end
+
+World do
+  Cucumber::Rails::World.new
+end

data/lib/cucumber/rake/task.rb

@@ -0,0 +1,241 @@
+require 'cucumber/platform'
+
+module Cucumber
+  module Rake
+    # Defines a Rake task for running features.
+    #
+    # The simplest use of it goes something like:
+    #
+    #   Cucumber::Rake::Task.new
+    #
+    # This will define a task named <tt>cucumber</tt> described as 'Run Cucumber features'. 
+    # It will use steps from 'features/**/*.rb' and features in 'features/**/*.feature'.
+    #
+    # To further configure the task, you can pass a block:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.cucumber_opts = %w{--format progress}
+    #   end
+    #
+    # This task can also be configured to be run with RCov:
+    #
+    #   Cucumber::Rake::Task.new do |t|
+    #     t.rcov = true
+    #   end
+    # 
+    # See the attributes for additional configuration possibilities.
+    class Task
+      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("\nWARNING: 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\n")
+          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
+      deprecate_accessor :step_list
+
+      # File pattern for finding step definitions. Defaults to 
+      # 'features/**/*.rb'.
+      deprecate_accessor :step_pattern
+
+      # Array of paths to specific features to run. 
+      deprecate_accessor :feature_list
+
+      # File pattern for finding features to run. Defaults to 
+      # '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
+      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.
+      # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
+      attr_accessor :rcov_opts
+      def rcov_opts=(opts) #:nodoc:
+        @rcov_opts = String === opts ? opts.split(' ') : opts
+      end
+
+      # Whether or not to fork a new ruby interpreter. Defaults to true. You may gain
+      # some startup speed if you set it to false, but this may also cause issues with
+      # your load path and gems.
+      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 = "cucumber", desc = "Run Cucumber features")
+        @task_name, @desc = task_name, desc
+        @fork = true
+        @libs = ['lib']
+        @rcov_opts = %w{--rails --exclude osx\/objc,gems\/}
+
+        yield self if block_given?
+
+        @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
+
+        define_task
+      end
+
+      def define_task #:nodoc:
+        desc @desc
+        task @task_name do
+          runner.run
+        end
+      end
+
+      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
+          InProcessCucumberRunner.new(libs, cucumber_opts, feature_files(task_args))
+        end
+      end
+
+      def cucumber_opts_with_profile #:nodoc:
+        @profile ? [cucumber_opts, '--profile', @profile] : cucumber_opts
+      end
+
+      def feature_files(task_args = nil) #:nodoc:
+        if ENV['FEATURE']
+          FileList[ ENV['FEATURE'] ]
+        else
+          result = []
+          result += feature_list.to_a if feature_list
+          result += FileList[feature_pattern].to_a if feature_pattern
+          result = make_command_line_safe(result)
+          FileList[result]
+        end
+      end
+
+      def step_files(task_args = nil) #:nodoc:
+        if ENV['STEPS']
+          FileList[ ENV['STEPS'] ]
+        else
+          result = []
+          result += Array(step_list) if step_list
+          result += Array(FileList[step_pattern]) if step_pattern
+          FileList[result]
+        end
+      end
+
+      private
+      def make_command_line_safe(list)
+        list.map{|string| string.gsub(' ', '\ ')}
+      end
+    end
+
+    class FeatureTask < Task
+
+      def initialize(task_name = "feature", desc = "Run a specified feature with Cucumber.  #{task_name}[feature_name]")
+        super(task_name, desc)
+      end
+
+      def define_task #:nodoc:
+        desc @desc
+        task @task_name, :feature_name do |t, args|
+          runner(args).run
+        end
+      end
+
+      def feature_files(task_arguments) #:nodoc:
+        FileList[File.join("features", "**", "#{task_arguments[:feature_name]}.feature")]
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -0,0 +1,100 @@
+require 'cucumber/rb_support/rb_hook'
+
+module Cucumber
+  module RbSupport
+    # This module defines the methods you can use to define pure Ruby
+    # Step Definitions and Hooks. This module is mixed into the toplevel
+    # object.
+    module RbDsl
+      class << self
+        attr_writer :rb_language
+        
+        def alias_adverb(adverb)
+          alias_method adverb, :register_rb_step_definition
+        end
+
+        def build_rb_world_factory(world_modules, proc)
+          @rb_language.build_rb_world_factory(world_modules, proc)
+        end
+
+        def register_rb_hook(phase, tag_names, proc)
+          @rb_language.register_rb_hook(phase, tag_names, proc)
+        end
+
+        def register_rb_step_definition(regexp, proc)
+          @rb_language.register_rb_step_definition(regexp, proc)
+        end
+      end
+
+      # Registers any number of +world_modules+ (Ruby Modules) and/or a Proc.
+      # The +proc+ will be executed once before each scenario to create an
+      # Object that the scenario's steps will run within. Any +world_modules+
+      # will be mixed into this Object (via Object#extend).
+      #
+      # This method is typically called from one or more Ruby scripts under 
+      # <tt>features/support</tt>. You can call this method as many times as you 
+      # like (to register more modules), but if you try to register more than 
+      # one Proc you will get an error.
+      #
+      # Cucumber will not yield anything to the +proc+. Examples:
+      #
+      #    World do
+      #      MyClass.new
+      #    end
+      #
+      #    World(MyModule)
+      #
+      def World(*world_modules, &proc)
+        RbDsl.build_rb_world_factory(world_modules, proc)
+      end
+
+      # Registers a proc that will run before each Scenario. You can register as 
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def Before(*tag_names, &proc)
+        RbDsl.register_rb_hook('before', tag_names, proc)
+      end
+
+      # Registers a proc that will run after each Scenario. You can register as 
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def After(*tag_names, &proc)
+        RbDsl.register_rb_hook('after', tag_names, proc)
+      end
+
+      # Registers a proc that will run after each Step. You can register as 
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def AfterStep(*tag_names, &proc)
+        RbDsl.register_rb_hook('after_step', tag_names, proc)
+      end
+
+      # Registers a proc that will be called with a step definition argument if it 
+      # matches the pattern passed as the first argument to Transform. Alternatively, if
+      # the pattern contains captures then they will be yielded as arguments to the
+      # provided proc. The return value of the proc is consequently yielded to the
+      # step definition.
+      def Transform(*args, &proc)
+        StepMother.register_transform(*args, &proc)
+      end
+      
+      # Registers a proc that will run after Cucumber is configured. You can register as 
+      # as you want (typically from ruby scripts under <tt>support/hooks.rb</tt>).
+      def AfterConfiguration(&proc)
+        RbDsl.register_rb_hook('after_configuration', [], proc)
+      end      
+
+      # Registers a new Ruby StepDefinition. This method is aliased
+      # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>, and
+      # also to the i18n translations whenever a feature of a
+      # new language is loaded.
+      #
+      # The +&proc+ gets executed in the context of a <tt>World</tt>
+      # object, which is defined by #World. A new <tt>World</tt>
+      # object is created for each scenario and is shared across
+      # step definitions within that scenario.
+      def register_rb_step_definition(regexp, &proc)
+        RbDsl.register_rb_step_definition(regexp, proc)
+      end
+    end
+  end
+end
+
+extend(Cucumber::RbSupport::RbDsl)

data/lib/cucumber/rb_support/rb_hook.rb

@@ -0,0 +1,18 @@
+module Cucumber
+  module RbSupport
+    # Wrapper for Before, After and AfterStep hooks
+    class RbHook
+      attr_reader :tag_names
+      
+      def initialize(rb_language, tag_names, proc)
+        @rb_language = rb_language
+        @tag_names = tag_names
+        @proc = proc
+      end
+
+      def invoke(location, argument)
+        @rb_language.current_world.cucumber_instance_exec(false, location, argument, &@proc)
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_language.rb

@@ -0,0 +1,153 @@
+require 'cucumber/rb_support/rb_dsl'
+require 'cucumber/rb_support/rb_world'
+require 'cucumber/rb_support/rb_step_definition'
+
+module Cucumber
+  module RbSupport
+    # Raised if a World block returns Nil.
+    class NilWorld < StandardError
+      def initialize
+        super("World procs should never return nil")
+      end
+    end
+
+    # Raised if there are 2 or more World blocks.
+    class MultipleWorld < StandardError
+      def initialize(first_proc, second_proc)
+        message = "You can only pass a proc to #World once, but it's happening\n"
+        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 Cucumber::RbSupport::RbDsl#World RDoc\n"
+        message << "or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.\n\n"
+        super(message)
+      end
+    end
+
+    # The Ruby implementation of the programming language API.
+    class RbLanguage
+      include LanguageSupport::LanguageMethods
+      attr_reader :current_world
+      
+      def initialize(step_mother)
+        @step_mother = step_mother
+        RbDsl.rb_language = self
+      end
+
+      def alias_adverbs(adverbs)
+        adverbs.each do |adverb|
+          RbDsl.alias_adverb(adverb)
+          RbWorld.alias_adverb(adverb)
+        end
+      end
+
+      def step_definitions_for(code_file)
+        begin
+          load_code_file(code_file)
+          step_definitions
+        rescue LoadError => e
+          e.message << "\nFailed to load #{code_file}"
+          raise e
+        ensure
+          @step_definitions = nil
+        end
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg_class = nil)
+        escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
+        escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
+
+        n = 0
+        block_args = escaped.scan(ESCAPED_PARAM_PATTERN).map do |a|
+          n += 1
+          "arg#{n}"
+        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_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_comment}pending\nend"
+      end
+
+      def begin_rb_scenario
+        create_world
+        extend_world
+        connect_world
+      end
+
+      def register_rb_hook(phase, tag_names, proc)
+        add_hook(phase, RbHook.new(self, tag_names, proc))
+      end
+
+      def register_rb_step_definition(regexp, proc)
+        add_step_definition(RbStepDefinition.new(self, regexp, proc))
+      end
+
+      def build_rb_world_factory(world_modules, proc)
+        if(proc)
+          raise MultipleWorld.new(@world_proc, proc) if @world_proc
+          @world_proc = proc
+        end
+        @world_modules ||= []
+        @world_modules += world_modules
+      end
+
+      protected
+
+      def load_code_file(code_file)
+        require code_file # This will cause self.add_step_definition and self.add_hook to be called from RbDsl
+      end
+
+      def begin_scenario
+        begin_rb_scenario
+      end
+      
+      def end_scenario
+        @current_world = nil
+      end
+
+      private
+
+      PARAM_PATTERN = /"([^\"]*)"/
+      ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
+
+      def create_world
+        if(@world_proc)
+          @current_world = @world_proc.call
+          check_nil(@current_world, @world_proc)
+        else
+          @current_world = Object.new
+        end
+      end
+
+      def extend_world
+        @current_world.extend(RbWorld)
+        @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+        (@world_modules || []).each do |mod|
+          @current_world.extend(mod)
+        end
+      end
+
+      def connect_world
+        @current_world.__cucumber_step_mother = @step_mother
+      end
+
+      def check_nil(o, proc)
+        if o.nil?
+          begin
+            raise NilWorld.new
+          rescue NilWorld => e
+            e.backtrace.clear
+            e.backtrace.push(proc.backtrace_line("World"))
+            raise e
+          end
+        else
+          o
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -0,0 +1,60 @@
+require 'cucumber/step_match'
+require 'cucumber/core_ext/string'
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  module RbSupport
+    # A Ruby Step Definition holds a Regexp and a Proc, and is created
+    # by calling <tt>Given</tt>, <tt>When</tt> or <tt>Then</tt>
+    # in the <tt>step_definitions</tt> ruby files. See also RbDsl.
+    #
+    # Example:
+    #
+    #   Given /I have (\d+) cucumbers in my belly/ do
+    #     # some code here
+    #   end
+    #
+    class RbStepDefinition
+      include LanguageSupport::StepDefinitionMethods
+
+      class MissingProc < StandardError
+        def message
+          "Step definitions must always have a proc"
+        end
+      end
+
+      attr_reader :proc
+
+      def initialize(rb_language, pattern, proc)
+        raise MissingProc if proc.nil?
+        if String === pattern
+          p = pattern.gsub(/\$\w+/, '(.*)') # Replace $var with (.*)
+          pattern = Regexp.new("^#{p}$") 
+        end
+        @rb_language, @regexp, @proc = rb_language, pattern, proc
+      end
+
+      def regexp
+        @regexp
+      end
+
+      def invoke(args)
+        args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
+        begin
+          @rb_language.current_world.cucumber_instance_exec(true, regexp.inspect, *args, &@proc)
+        rescue Cucumber::ArityMismatchError => e
+          e.backtrace.unshift(self.backtrace_line)
+          raise e
+        end
+      end
+
+      def file_colon_line
+        @proc.file_colon_line
+      end
+    
+      def file
+        @file ||= file_colon_line.split(':')[0]
+      end
+    end
+  end
+end