cavalle-cucumber 0.2.3.3.1

data/lib/cucumber/rails/world.rb

@@ -0,0 +1,74 @@
+# 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
+require 'test/unit/testresult'
+
+# 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 World.
+    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
+      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
+        def rescue_action(exception)
+          raise exception
+        end
+      end
+      ActionController::Dispatcher.class_eval do
+        def self.failsafe_response(output, status, exception = nil)
+          raise exception
+        end
+      end
+    end
+  end
+end
+
+World do
+  Cucumber::Rails::World.new
+end

data/lib/cucumber/rake/task.rb

@@ -0,0 +1,138 @@
+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 create a task named 'features' described as 'Run Features with 
+    # Cucumber'. 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 = "--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
+      LIB    = File.expand_path(File.dirname(__FILE__) + '/../..') # :nodoc:
+
+      # 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
+      # File pattern for finding step definitions. Defaults to 
+      # 'features/**/*.rb'.
+      attr_accessor :step_pattern
+      # Array of paths to specific features to run. 
+      attr_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
+      # Extra options to pass to the cucumber binary. Can be overridden by the CUCUMBER_OPTS environment variable.
+      attr_accessor :cucumber_opts
+      # Run cucumber with RCov?
+      attr_accessor :rcov
+      # Extra options to pass to rcov
+      attr_accessor :rcov_opts
+
+      # Define a Rake
+      def initialize(task_name = "features", desc = "Run Features with Cucumber")
+        @task_name, @desc = task_name, desc
+        @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
+          ruby(arguments_for_ruby_execution.join(" ")) # ruby(*args) is broken on Windows
+        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
+        else
+          args = (['-I'] + lib_args + cucumber_bin + cuc_opts + feature_files(task_args)).flatten
+        end
+
+        args
+      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
+          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
+    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|
+          ruby(arguments_for_ruby_execution(args).join(" ")) # ruby(*args) is broken on Windows
+        end
+      end
+
+      def feature_files(task_arguments) # :nodoc:
+        FileList[File.join("features", "**", "#{task_arguments[:feature_name]}.feature")]
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/step_definition.rb

@@ -0,0 +1,113 @@
+require 'cucumber/step_match'
+require 'cucumber/core_ext/string'
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  module StepDefinitionMethods
+    def step_match(name_to_match, name_to_report)
+      if(match = name_to_match.match(regexp))
+        StepMatch.new(self, name_to_match, name_to_report, match.captures)
+      else
+        nil
+      end
+    end
+
+    # Formats the matched arguments of the associated Step. This method
+    # is usually called from visitors, which render output.
+    #
+    # The +format+ can either be a String or a Proc.
+    #
+    # If it is a String it should be a format string according to
+    # <tt>Kernel#sprinf</tt>, for example:
+    #
+    #   '<span class="param">%s</span></tt>'
+    #
+    # If it is a Proc, it should take one argument and return the formatted
+    # argument, for example:
+    #
+    #   lambda { |param| "[#{param}]" }
+    #
+    def format_args(step_name, format)
+      step_name.gzub(regexp, format)
+    end
+
+    def match(step_name)
+      case step_name
+      when String then regexp.match(step_name)
+      when Regexp then regexp == step_name
+      end
+    end
+
+    def backtrace_line
+      "#{file_colon_line}:in `#{regexp.inspect}'"
+    end
+
+    def text_length
+      regexp.inspect.jlength
+    end
+  end
+  
+  # A 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 - for example:
+  #
+  #   Given /I have (\d+) cucumbers in my belly/ do
+  #     # some code here
+  #   end
+  #
+  class StepDefinition
+    PARAM_PATTERN = /"([^\"]*)"/
+    ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
+    
+    def self.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_string = multiline_arg_class ? "# #{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n  " : ""
+
+      "#{step_keyword} /^#{escaped}$/ do#{block_arg_string}\n  #{multiline_class_string}pending\nend"
+    end
+
+    class MissingProc < StandardError
+      def message
+        "Step definitions must always have a proc"
+      end
+    end
+
+    include StepDefinitionMethods
+
+    def initialize(pattern, &proc)
+      raise MissingProc if proc.nil?
+      if String === pattern
+        p = pattern.gsub(/\$\w+/, '(.*)') # Replace $var with (.*)
+        pattern = Regexp.new("^#{p}$") 
+      end
+      @regexp, @proc = pattern, proc
+    end
+
+    def regexp
+      @regexp
+    end
+
+    def invoke(world, args)
+      args = args.map{|arg| Ast::PyString === arg ? arg.to_s : arg}
+      begin
+        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
+  end
+end

data/lib/cucumber/step_match.rb

@@ -0,0 +1,57 @@
+module Cucumber
+  class StepMatch
+    attr_reader :step_definition
+    attr_reader :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 invoke(world, multiline_arg)
+      all_args = @args.dup
+      all_args << multiline_arg if multiline_arg
+      @step_definition.invoke(world, all_args)
+    end
+
+    def format_args(format = lambda{|a| a})
+      @formatted_step_name || @step_definition.format_args(@step_name, format)
+    end
+    
+    def file_colon_line
+      @step_definition.file_colon_line
+    end
+
+    def backtrace_line
+      @step_definition.backtrace_line
+    end
+
+    def text_length
+      @step_definition.text_length
+    end
+  end
+  
+  class NoStepMatch
+    attr_reader :step_definition
+
+    def initialize(step)
+      @step = step
+    end
+    
+    def format_args(format)
+      @step.name
+    end
+
+    def file_colon_line
+      raise "No file:line for #{@step}" unless @step.file_colon_line
+      @step.file_colon_line
+    end
+
+    def backtrace_line
+      @step.backtrace_line
+    end
+
+    def text_length
+      @step.text_length
+    end
+  end
+end

data/lib/cucumber/step_mother.rb

@@ -0,0 +1,290 @@
+require 'cucumber/step_definition'
+require 'cucumber/world'
+require 'cucumber/core_ext/instance_exec'
+
+module Cucumber
+  class Undefined < StandardError
+    attr_reader :step_name
+
+    def initialize(step_name)
+      super %{Undefined step: "#{step_name}"}
+      @step_name = step_name
+    end
+    
+    def nested!
+      @nested = true
+    end
+
+    def nested?
+      @nested
+    end
+  end
+
+  # Raised when a StepDefinition's block invokes World#pending
+  class Pending < StandardError
+  end
+
+  # Raised when a step matches 2 or more StepDefinition
+  class Ambiguous < StandardError
+    def initialize(step_name, step_definitions, used_guess)
+      message = "Ambiguous match of \"#{step_name}\":\n\n"
+      message << step_definitions.map{|sd| sd.backtrace_line}.join("\n")
+      message << "\n\n"
+      message << "You can run again with --guess to make Cucumber be more smart about it\n" unless used_guess
+      super(message)
+    end
+  end
+
+  # Raised when 2 or more StepDefinition have the same Regexp
+  class Redundant < StandardError
+    def initialize(step_def_1, step_def_2)
+      message = "Multiple step definitions have the same Regexp:\n\n"
+      message << step_def_1.backtrace_line << "\n"
+      message << step_def_2.backtrace_line << "\n\n"
+      super(message)
+    end
+  end
+
+  class NilWorld < StandardError
+    def initialize
+      super("World procs should never return nil")
+    end
+  end
+
+  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 #World RDoc.\n\n"
+      super(message)
+    end
+  end
+
+  # This is the main interface for registering step definitions, which is done
+  # from <tt>*_steps.rb</tt> files. This module is included right at the top-level
+  # so #register_step_definition (and more interestingly - its aliases) are
+  # available from the top-level.
+  module StepMother
+    class << self
+      def alias_adverb(adverb)
+        adverb = adverb.gsub(/\s/, '')
+        alias_method adverb, :register_step_definition
+      end
+    end
+
+    attr_writer :snippet_generator, :options, :visitor
+
+    def step_visited(step)
+      steps << step unless steps.index(step)
+    end
+    
+    def steps(status = nil)
+      @steps ||= []
+      if(status)
+        @steps.select{|step| step.status == status}
+      else
+        @steps
+      end
+    end
+
+    def scenarios
+      @scenarios ||= []
+    end
+
+    # Registers a new StepDefinition. This method is aliased
+    # to <tt>Given</tt>, <tt>When</tt> and <tt>Then</tt>.
+    #
+    # See Cucumber#alias_steps for details on how to
+    # create your own aliases.
+    #
+    # 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_step_definition(regexp, &proc)
+      step_definition = StepDefinition.new(regexp, &proc)
+      step_definitions.each do |already|
+        raise Redundant.new(already, step_definition) if already.match(regexp)
+      end
+      step_definitions << step_definition
+      step_definition
+    end
+
+    # 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
+    end
+
+    def After(&proc)
+      (@after_procs ||= []).unshift(proc)
+    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+ (like it used to do before v0.3).
+    #
+    # In earlier versions of Cucumber (before 0.3) you could not register
+    # any +world_modules+. Instead you would register several Proc objects (by 
+    # calling the method several times). The result of each +proc+ would be yielded 
+    # to the next +proc+. Example:
+    #
+    #   World do |world| # NOT SUPPORTED FROM 0.3
+    #     MyClass.new
+    #   end
+    #
+    #   World do |world| # NOT SUPPORTED FROM 0.3
+    #     world.extend(MyModule)
+    #   end
+    #
+    # From Cucumber 0.3 the recommended way to do this is:
+    #
+    #    World do
+    #      MyClass.new
+    #    end
+    #
+    #    World(MyModule)
+    #
+    def World(*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
+
+    def current_world
+      @current_world
+    end
+
+    def step_match(step_name, formatted_step_name=nil)
+      matches = step_definitions.map { |d| d.step_match(step_name, formatted_step_name) }.compact
+      raise Undefined.new(step_name) if matches.empty?
+      matches = best_matches(step_name, matches) if matches.size > 1 && options[:guess]
+      raise Ambiguous.new(step_name, matches, options[:guess]) if matches.size > 1
+      matches[0]
+    end
+
+    def best_matches(step_name, step_matches)
+      max_arg_length = step_matches.map {|step_match| step_match.args.length }.max
+      top_groups     = step_matches.select {|step_match| step_match.args.length == max_arg_length }
+
+      if top_groups.length > 1
+        shortest_capture_length = top_groups.map {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } }.min
+        top_groups.select {|step_match| step_match.args.inject(0) {|sum, c| sum + c.length } == shortest_capture_length }
+      else
+        top_groups
+      end
+    end
+    
+    def step_definitions
+      @step_definitions ||= []
+    end
+
+    def snippet_text(step_keyword, step_name, multiline_arg_class)
+      @snippet_generator.snippet_text(step_keyword, step_name, multiline_arg_class)
+    end
+
+    def before_and_after(scenario, skip=false)
+      unless current_world || skip
+        new_world!
+        execute_before(scenario)
+      end
+      if block_given?
+        yield
+        execute_after(scenario) unless skip
+        nil_world!
+        scenario_visited(scenario)
+      end
+    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!
+      create_world!
+      extend_world
+      connect_world
+      @current_world
+    end
+
+    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(World)
+      @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 = self
+      @current_world.__cucumber_visitor = @visitor
+    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
+
+    def nil_world!
+      @current_world = nil
+    end
+
+    def execute_before(scenario)
+      (@before_procs ||= []).each do |proc|
+        @current_world.cucumber_instance_exec(false, 'Before', scenario, &proc)
+      end
+    end
+
+    def execute_after(scenario)
+      (@after_procs ||= []).each do |proc|
+        @current_world.cucumber_instance_exec(false, 'After', scenario, &proc)
+      end
+    end
+
+    def scenario_visited(scenario)
+      scenarios << scenario unless scenarios.index(scenario)
+    end
+
+    def options
+      @options || {}
+    end
+  end
+end

data/lib/cucumber/version.rb

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