jwilger-cucumber 0.3.11.200906161550

data/lib/cucumber/step_mother.rb

@@ -0,0 +1,362 @@
+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 Cucumber::StepMother#World RDoc\n"
+      message << "or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.\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 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/, '')
+        alias_method adverb, :register_step_definition
+      end
+    end
+
+    attr_writer :snippet_generator, :options, :visitor
+
+    def options
+      @options ||= {}
+    end
+
+    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(status = nil)
+      @scenarios ||= []
+      if(status)
+        @scenarios.select{|scenario| scenario.status == status}
+      else
+        @scenarios
+      end
+    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(*tag_names, &proc)
+      register_hook(:before, tag_names, proc)
+    end
+
+    def After(*tag_names, &proc)
+      register_hook(:after, tag_names, proc)
+    end
+
+    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.
+    # 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 clear!
+      step_definitions.clear
+      hooks.clear
+      steps.clear
+      scenarios.clear
+    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_hooks=false)
+      before(scenario) unless skip_hooks
+      @current_scenario = scenario
+      yield scenario
+      @current_scenario = nil
+      after(scenario) unless skip_hooks
+      scenario_visited(scenario)
+    end
+    
+    def before(scenario)
+      unless current_world
+        new_world!
+        execute_before(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
+
+    # Creates a new world instance
+    def new_world!
+      return if options[:dry_run]
+      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)
+      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)
+      return if options[:dry_run]
+      hooks_for(:after, scenario).each do |hook|
+        hook.execute_in(@current_world, scenario, 'After')
+      end
+    end
+
+    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 scenario_visited(scenario)
+      scenarios << scenario unless scenarios.index(scenario)
+    end
+  end
+end

data/lib/cucumber/version.rb

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

data/lib/cucumber/world.rb

@@ -0,0 +1,53 @@
+module Cucumber
+  # All steps are run in the context of an object that extends this module
+  module World
+    class << self
+      def alias_adverb(adverb)
+        alias_method adverb, :__cucumber_invoke
+      end
+    end
+    
+    attr_writer :__cucumber_step_mother, :__cucumber_visitor, :__cucumber_current_step
+
+    # Call a step from within a step definition
+    def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
+      begin
+        step_match = @__cucumber_step_mother.step_match(name)
+        step_match.invoke(self, multiline_argument)
+      rescue Exception => e
+        e.nested! if Undefined === e
+        @__cucumber_current_step.exception = e if @__cucumber_current_step
+        raise e
+      end
+    end
+    
+    def table(text, file=nil, line_offset=0)
+      @table_parser ||= Parser::TableParser.new
+      @table_parser.parse_or_fail(text.strip, file, line_offset)
+    end
+
+    # Output +announcement+ alongside the formatted output.
+    # This is an alternative to using Kernel#puts - it will display
+    # nicer, and in all outputs (in case you use several formatters)
+    #
+    # Beware that the output will be printed *before* the corresponding
+    # step. This is because the step itself will not be printed until
+    # after it has run, so it can be coloured according to its status.
+    def announce(announcement)
+      @__cucumber_visitor.announce(announcement)
+    end
+
+    def pending(message = "TODO")
+      if block_given?
+        begin
+          yield
+        rescue Exception => e
+          raise Pending.new(message)
+        end
+        raise Pending.new("Expected pending '#{message}' to fail. No Error was raised. No longer pending?")
+      else
+        raise Pending.new(message)
+      end
+    end
+  end
+end

data/lib/cucumber.rb

@@ -0,0 +1,11 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'yaml'
+require 'cucumber/platform'
+require 'cucumber/parser'
+require 'cucumber/version'
+require 'cucumber/step_mother'
+require 'cucumber/cli/main'
+require 'cucumber/broadcaster'
+require 'cucumber/core_ext/exception'

data/rails_generators/cucumber/USAGE

@@ -0,0 +1,11 @@
+Description:
+    Sets up Cucumber in your Rails project. After running this generator you will
+    get a new rake task called features.
+    
+    This also generates the necessary files in the features directory.
+    
+    Also see the feature generator, which you can use to generate skeletons
+    for new features.
+    
+Examples:
+    `./script/generate cucumber`

data/rails_generators/cucumber/cucumber_generator.rb

@@ -0,0 +1,66 @@
+require 'rbconfig'
+require 'cucumber/version'
+
+# This generator bootstraps a Rails project for use with Cucumber
+class CucumberGenerator < Rails::Generator::Base
+  DEFAULT_SHEBANG = File.join(Config::CONFIG['bindir'],
+                              Config::CONFIG['ruby_install_name'])
+
+  attr_accessor :framework
+
+  def manifest
+    record do |m|
+      m.directory 'features/step_definitions'
+      m.template  'webrat_steps.rb', 'features/step_definitions/webrat_steps.rb'
+      m.template  'cucumber_environment.rb', 'config/environments/cucumber.rb',
+        :assigns => { :cucumber_version => ::Cucumber::VERSION::STRING }
+
+      m.gsub_file 'config/database.yml', /test:.*\n/, "test: &TEST\n"
+      m.gsub_file 'config/database.yml', /\z/, "\ncucumber:\n  <<: *TEST"
+
+      m.directory 'features/support'
+
+      if options[:spork]
+        m.template  'spork_env.rb',     'features/support/env.rb'
+      else
+        m.template  'env.rb',           'features/support/env.rb'
+      end
+
+      m.file      'paths.rb',         'features/support/paths.rb'
+
+      m.directory 'lib/tasks'
+      m.template  'cucumber.rake',    'lib/tasks/cucumber.rake'
+
+      m.file      'cucumber',         'script/cucumber', {
+        :chmod => 0755, :shebang => options[:shebang] == DEFAULT_SHEBANG ? nil : options[:shebang]
+      }
+    end
+  end
+
+  def framework
+    options[:framework] || :rspec
+  end
+
+protected
+
+  def banner
+    "Usage: #{$0} cucumber"
+  end
+
+  def add_options!(opt)
+    opt.separator ''
+    opt.separator 'Options:'
+    opt.on('--rspec', 'Setup cucumber for use with RSpec (default)') do |value|
+      options[:framework] = :rspec
+    end
+
+    opt.on('--testunit', 'Setup cucumber for use with test/unit') do |value|
+      options[:framework] = :testunit
+    end
+
+    opt.on('--spork', 'Setup cucumber for use with Spork') do |value|
+      options[:spork] = true
+    end
+  end
+
+end

data/rails_generators/cucumber/templates/cucumber

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+begin
+  load File.expand_path(File.dirname(__FILE__) + "/../vendor/plugins/cucumber/bin/cucumber")
+rescue LoadError => e
+  raise unless e.to_s =~ /cucumber/  
+  require "rubygems"
+  load File.join(Gem.bindir, "cucumber")
+end

data/rails_generators/cucumber/templates/cucumber.rake

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift(RAILS_ROOT + '/vendor/plugins/cucumber/lib') if File.directory?(RAILS_ROOT + '/vendor/plugins/cucumber/lib')
+
+unless ARGV.any? {|a| a =~ /^gems/}
+
+begin
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new(:features) do |t|
+    t.fork = true
+    t.cucumber_opts = [<%= options[:spork] ? "'--drb', " : "" %>'--format', (ENV['CUCUMBER_FORMAT'] || 'pretty')]
+  end
+  task :features => 'db:test:prepare'
+rescue LoadError
+  desc 'Cucumber rake task not available'
+  task :features do
+    abort 'Cucumber rake task is not available. Be sure to install cucumber as a gem or plugin'
+  end
+end
+
+end

data/rails_generators/cucumber/templates/cucumber_environment.rb

@@ -0,0 +1,23 @@
+config.cache_classes = true # This must be true for Cucumber to operate correctly!
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+
+# Disable request forgery protection in test environment
+config.action_controller.allow_forgery_protection    = false
+
+# Tell Action Mailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test
+
+config.gem "cucumber",    :lib => false,        :version => ">=<%= cucumber_version %>" unless File.directory?(File.join(Rails.root, 'vendor/plugins/cucumber'))
+config.gem "webrat",      :lib => false,        :version => ">=0.4.4" unless File.directory?(File.join(Rails.root, 'vendor/plugins/webrat'))
+<% if framework == :rspec -%>
+config.gem "rspec",       :lib => false,        :version => ">=1.2.6" unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec'))
+config.gem "rspec-rails", :lib => 'spec/rails', :version => ">=1.2.6" unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec-rails'))
+<% end %>

data/rails_generators/cucumber/templates/env.rb

@@ -0,0 +1,26 @@
+# Sets up the Rails environment for Cucumber
+ENV["RAILS_ENV"] ||= "cucumber"
+require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+require 'cucumber/rails/world'
+
+# Comment out the next line if you don't want Cucumber Unicode support
+require 'cucumber/formatter/unicode'
+
+# Comment out the next line if you don't want transactions to
+# open/roll back around each scenario
+Cucumber::Rails.use_transactional_fixtures
+
+# Comment out the next line if you want Rails' own error handling
+# (e.g. rescue_action_in_public / rescue_responses / rescue_from)
+Cucumber::Rails.bypass_rescue
+
+require 'webrat'
+
+Webrat.configure do |config|
+  config.mode = :rails
+end
+<% if framework == :rspec -%>
+
+require 'cucumber/rails/rspec'
+require 'webrat/core/matchers'
+<% end -%>

data/rails_generators/cucumber/templates/paths.rb

@@ -0,0 +1,27 @@
+module NavigationHelpers
+  # Maps a name to a path. Used by the
+  #
+  #   When /^I go to (.+)$/ do |page_name|
+  #
+  # step definition in webrat_steps.rb
+  #
+  def path_to(page_name)
+    case page_name
+    
+    when /the homepage/
+      '/'
+    
+    # Add more mappings here.
+    # Here is a more fancy example:
+    #
+    #   when /^(.*)'s profile page$/i
+    #     user_profile_path(User.find_by_login($1))
+
+    else
+      raise "Can't find mapping from \"#{page_name}\" to a path.\n" +
+        "Now, go and add a mapping in #{__FILE__}"
+    end
+  end
+end
+
+World(NavigationHelpers)

data/rails_generators/cucumber/templates/spork_env.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'spork'
+ 
+Spork.prefork do
+  # Sets up the Rails environment for Cucumber
+  ENV["RAILS_ENV"] = "cucumber"
+  require File.expand_path(File.dirname(__FILE__) + '/../../config/environment')
+ 
+  require 'webrat'
+ 
+  Webrat.configure do |config|
+    config.mode = :rails
+  end
+ 
+  require 'webrat/core/matchers'
+  require 'cucumber'
+
+  # Comment out the next line if you don't want Cucumber Unicode support
+  require 'cucumber/formatter/unicode'
+
+  require 'spec/rails'
+  require 'cucumber/rails/rspec'
+end
+ 
+Spork.each_run do
+  # This code will be run each time you run your specs.
+  require 'cucumber/rails/world'
+
+  # Comment out the next line if you don't want transactions to
+  # open/roll back around each scenario
+  Cucumber::Rails.use_transactional_fixtures
+
+  # Comment out the next line if you want Rails' own error handling
+  # (e.g. rescue_action_in_public / rescue_responses / rescue_from)
+  Cucumber::Rails.bypass_rescue
+end