aslakhellesoy-cucumber 0.3.95 → 0.3.96

data/lib/cucumber/step_mother.rb

@@ -1,6 +1,10 @@
-require 'cucumber/step_definition'
+require 'cucumber/constantize'
 require 'cucumber/world'
 require 'cucumber/core_ext/instance_exec'
+require 'cucumber/parser/natural_language'
+require 'cucumber/language_support/hook_methods'
+require 'cucumber/language_support/language_methods'
+require 'cucumber/language_support/step_definition_methods'
 
 module Cucumber
   class Undefined < StandardError
@@ -45,61 +49,56 @@ module Cucumber
     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
+  class StepMother
+    include Constantize
+    
+    attr_writer :options, :visitor
 
-      def matches_tag_names?(tag_names)
-        @tag_names.empty? || (@tag_names & tag_names).any?
-      end
+    def initialize
+      @programming_languages = []
+      @language_map = {}
+      load_natural_language('en')
+    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
+    # Loads and registers programming language implementation.
+    # Instances are cached, so calling with the same argument
+    # twice will return the same instance.
+    #
+    # Raises an exception if the language can't be loaded.
+    #
+    def load_programming_language(ext)
+      return @language_map[ext] if @language_map[ext]
+      programming_language_class = constantize("Cucumber::#{ext.capitalize}Support::#{ext.capitalize}Language")
+      programming_language = programming_language_class.new(self)
+      programming_language.alias_adverbs(@adverbs || [])
+      @programming_languages << programming_language
+      @language_map[ext] = programming_language
+      programming_language
+    end
+
+    # Loads a natural language. This has the effect of aliasing 
+    # Step Definition keywords for all of the registered programming 
+    # languages (if they support aliasing). See #load_programming_language
+    #
+    def load_natural_language(lang)
+      Parser::NaturalLanguage.get(self, lang)
     end
 
-    class << self
-      def alias_adverb(adverb)
-        adverb = adverb.gsub(/\s/, '')
-        alias_method adverb, :register_step_definition
+    # Registers a StepDefinition. This can be a Ruby StepDefintion,
+    # or any other kind of object that implements the StepDefintion
+    # contract (API).
+    def register_step_definition(step_definition)
+      step_definitions.each do |already|
+        raise Redundant.new(already, step_definition) if already.same_regexp?(step_definition.regexp)
       end
+      step_definitions << step_definition
+      step_definition
     end
 
-    attr_writer :snippet_generator, :options, :visitor
-
     def options
       @options ||= {}
     end
@@ -117,6 +116,10 @@ module Cucumber
       end
     end
 
+    def announce(msg)
+      @visitor.announce(msg)
+    end
+
     def scenarios(status = nil)
       @scenarios ||= []
       if(status)
@@ -126,44 +129,8 @@ module Cucumber
       end
     end
 
-    # Registers a new 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.
-    #
-    # 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
+    def register_hook(phase, hook)
+      hooks[phase.to_sym] << hook
       hook
     end
 
@@ -172,53 +139,7 @@ module Cucumber
     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
+      hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
     end
 
     def step_match(step_name, formatted_step_name=nil)
@@ -257,108 +178,68 @@ module Cucumber
     end
 
     def snippet_text(step_keyword, step_name, multiline_arg_class)
-      @snippet_generator.snippet_text(step_keyword, step_name, multiline_arg_class)
+      @programming_languages.map do |programming_language|
+        programming_language.snippet_text(step_keyword, step_name, multiline_arg_class)
+      end.join("\n")
     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
+    def register_adverbs(adverbs)
+      @adverbs ||= []
+      @adverbs += adverbs
+      @adverbs.uniq!
+      @programming_languages.each do |programming_language|
+        programming_language.alias_adverbs(@adverbs)
+      end
     end
 
-    # Creates a new world instance
-    def new_world!
+    def begin_scenario
       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
+      @programming_languages.each do |programming_language|
+        programming_language.begin_scenario
       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)
+    def end_scenario
+      return if options[:dry_run]
+      @programming_languages.each do |programming_language|
+        programming_language.end_scenario
       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
+    
+    def before(scenario)
+      return if options[:dry_run] || @current_scenario
+      @current_scenario = scenario
+      @programming_languages.each do |programming_language|
+        programming_language.before(scenario)
       end
     end
-
-    def nil_world!
-      @current_world = nil
-    end
-
-    def execute_before(scenario)
+    
+    def after(scenario)
+      @current_scenario = nil
       return if options[:dry_run]
-      hooks_for(:before, scenario).each do |hook|
-        hook.execute_in(@current_world, scenario, 'Before')
+      @programming_languages.each do |programming_language|
+        programming_language.after(scenario)
       end
     end
-
-    def execute_after(scenario)
+    
+    def after_step
       return if options[:dry_run]
-      hooks_for(:after, scenario).each do |hook|
-        hook.execute_in(@current_world, scenario, 'After')
+      @programming_languages.each do |programming_language|
+        programming_language.execute_after_step(@current_scenario)
       end
     end
+    
+    private
 
-    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
+    def max_step_definition_length
+      @max_step_definition_length ||= step_definitions.map{|step_definition| step_definition.text_length}.max
     end
 
     def scenario_visited(scenario)

data/lib/cucumber/version.rb

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

data/lib/cucumber/webrat/element_locator.rb

@@ -1,15 +1,15 @@
 module Webrat
   class Element
-    # Returns an Array of Array of String where each String is the
-    # a "cell" in the table-like structure represented by this Element.
+    # Returns an Array of Array of String where each String is a
+    # "cell" in the table-like structure represented by this Element.
     #
-    # Supported elements are table, dl, ol and ul. The return value depends
-    # on the type of the element:
+    # Supported elements are table, dl, ol and ul. Different conversion
+    # strategies are used depending on the kind of element:
     #
-    # * table    : Each tr is a row. The innerHTML of each tr or th becomes cells. The number 
+    # * table    : Each tr becomes a row. The innerHTML of each td or th inside becomes a cell. The number 
     #              of columns is determined by the number of cells in the first row.
-    # * dl       : Each dt creates a row with 2 cells. The innerHTML of the dt itself and the next dd become cells.
-    # * ul or ol : Each ul creates a row with one cell, the innerHTML of the ul.
+    # * dl       : Each dt becomes a row with 2 cells. The innerHTML of the dt itself and the next dd become cells.
+    # * ul or ol : Each li becomes a row with one cell, the innerHTML of the li.
     #
     def to_table
       case element.name

data/lib/cucumber/world.rb

@@ -7,23 +7,43 @@ module Cucumber
       end
     end
     
-    attr_writer :__cucumber_step_mother, :__cucumber_visitor, :__cucumber_current_step
+    attr_writer :__cucumber_step_mother
 
     # 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)
+        step_match.invoke(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)
+
+    # Returns a Cucumber::Ast::Table for +text_or_table+, which can either
+    # be a String:
+    #
+    #   table(%{
+    #     | account | description | amount |
+    #     | INT-100 | Taxi        | 114    |
+    #     | CUC-101 | Peeler      | 22     |
+    #   })
+    #
+    # or a 2D Array:
+    #
+    #   table([
+    #     %w{ account description amount },
+    #     %w{ INT-100 Taxi        114    },
+    #     %w{ CUC-101 Peeler      22     }
+    #   ])
+    #
+    def table(text_or_table, file=nil, line_offset=0)
+      if Array === text_or_table
+        Ast::Table.new(text_or_table)
+      else
+        @table_parser ||= Parser::TableParser.new
+        @table_parser.parse_or_fail(text_or_table.strip, file, line_offset)
+      end
     end
 
     # Output +announcement+ alongside the formatted output.
@@ -34,7 +54,7 @@ module Cucumber
     # 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)
+      @__cucumber_step_mother.announce(announcement)
     end
 
     def pending(message = "TODO")

data/rails_generators/cucumber/templates/cucumber_environment.rb

@@ -16,11 +16,11 @@ config.action_controller.allow_forgery_protection    = false
 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'))
+config.gem 'webrat',      :lib => false,        :version => '>=0.5.0' 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 %>
 <% if spork? -%>
-config.gem 'spork',       :lib => false,        :version => '>=0.5.7' unless File.directory?(File.join(Rails.root, 'vendor/plugins/spork'))
+config.gem 'spork',       :lib => false,        :version => '>=0.5.9' unless File.directory?(File.join(Rails.root, 'vendor/plugins/spork'))
 <% end %>

data/rails_generators/cucumber/templates/spork_env.rb

@@ -18,14 +18,12 @@ Spork.prefork do
 
   # 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

data/rails_generators/cucumber/templates/webrat_steps.rb

@@ -27,6 +27,23 @@ When /^I fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
   fill_in(field, :with => value) 
 end
 
+# Use this to fill in an entire form with data from a table. Example:
+#
+#   When I fill in the following:
+#     | Account Number | 5002       |
+#     | Expiry date    | 2009-11-01 |
+#     | Note           | Nice guy   |
+#     | Wants Email?   |            |
+#
+# TODO: Add support for checkbox, select og option
+# based on naming conventions.
+#
+When /^I fill in the following:$/ do |fields|
+  fields.rows_hash.each do |name, value|
+    When %{I fill in "#{name}" with "#{value}"}
+  end
+end
+
 When /^I select "([^\"]*)" from "([^\"]*)"$/ do |value, field|
   select(value, :from => field) 
 end

data/spec/cucumber/ast/background_spec.rb

@@ -1,18 +1,22 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/ast'
+require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   module Ast
     describe Background do
 
       before do
-        @step_mother = Object.new
-        @step_mother.extend(StepMother)
+        extend(RbSupport::RbDsl)
+        @step_mother = StepMother.new
+        @step_mother.load_natural_language('en')
+        @step_mother.load_programming_language('rb')
+
         $x = $y = nil
-        @step_mother.Before do
+        Before do
           $x = 2
         end
-        @step_mother.Given /y is (\d+)/ do |n|
+        Given /y is (\d+)/ do |n|
           $y = $x * n.to_i
         end
         @visitor = Visitor.new(@step_mother)
@@ -40,7 +44,6 @@ module Cucumber
           name="", 
           steps=[])
         background.feature = @feature
-        
         @visitor.visit_background(background)
         $x.should == 2
         $y.should == 10

data/spec/cucumber/ast/feature_factory.rb

@@ -10,14 +10,13 @@ module Cucumber
         end
       end
       
-      def create_feature(step_mother)
-        step_mother.extend(StepMother)
-        step_mother.Given /^a (.*) step with an inline arg:$/ do |what, table|
+      def create_feature(dsl)
+        dsl.Given /^a (.*) step with an inline arg:$/ do |what, table|
         end
-        step_mother.Given /^a (.*) step$/ do |what|
+        dsl.Given /^a (.*) step$/ do |what|
           flunk if what == 'failing'
         end
-        step_mother.World do
+        dsl.World do
           MyWorld.new
         end
 

data/spec/cucumber/ast/feature_spec.rb

@@ -7,7 +7,13 @@ module Cucumber
       include FeatureFactory
 
       it "should convert to sexp" do
-        feature = create_feature(Object.new)
+        step_mother = StepMother.new
+        step_mother.load_natural_language('en')
+        step_mother.load_programming_language('rb')
+        dsl = Object.new 
+        dsl.extend RbSupport::RbDsl
+
+        feature = create_feature(dsl)
         feature.to_sexp.should == 
         [:feature,
           "features/pretty_printing.feature",

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -2,24 +2,28 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/step_mother'
 require 'cucumber/ast'
 require 'cucumber/core_ext/string'
+require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   module Ast
     describe ScenarioOutline do
       before do
-        @step_mother = Object.new
-        @step_mother.extend(StepMother)
+        @step_mother = StepMother.new
+        @step_mother.load_programming_language('rb')
+        @step_mother.load_natural_language('en')
+        @dsl = Object.new
+        @dsl.extend(RbSupport::RbDsl)
 
-        @step_mother.Given(/^there are (\d+) cucumbers$/) do |n|
+        @dsl.Given(/^there are (\d+) cucumbers$/) do |n|
           @initial = n.to_i
         end
-        @step_mother.When(/^I eat (\d+) cucumbers$/) do |n|
+        @dsl.When(/^I eat (\d+) cucumbers$/) do |n|
           @eaten = n.to_i
         end
-        @step_mother.Then(/^I should have (\d+) cucumbers$/) do |n|
+        @dsl.Then(/^I should have (\d+) cucumbers$/) do |n|
           (@initial - @eaten).should == n.to_i
         end
-        @step_mother.Then(/^I should have (\d+) cucumbers in my belly$/) do |n|
+        @dsl.Then(/^I should have (\d+) cucumbers in my belly$/) do |n|
           @eaten.should == n.to_i
         end
 

data/spec/cucumber/ast/scenario_spec.rb

@@ -1,15 +1,20 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 require 'cucumber/step_mother'
 require 'cucumber/ast'
+require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   module Ast
     describe Scenario do
       before do
-        @step_mother = Object.new
-        @step_mother.extend(StepMother)
+        @step_mother = StepMother.new
+        @step_mother.load_natural_language('en')
+        @step_mother.load_programming_language('rb')
+        @dsl = Object.new
+        @dsl.extend(RbSupport::RbDsl)
+
         $x = $y = nil
-        @step_mother.Given /y is (\d+)/ do |n|
+        @dsl.Given /y is (\d+)/ do |n|
           $y = n.to_i
         end
         @visitor = Visitor.new(@step_mother)

data/spec/cucumber/ast/step_collection_spec.rb

@@ -6,8 +6,8 @@ module Cucumber
       it "should convert And to Given in snippets" do
         s1 = Step.new(1, 'Given', 'cukes')
         s2 = Step.new(2, 'And', 'turnips')
-        s1.stub!(:language).and_return(Parser::I18n::Language['en'])
-        s2.stub!(:language).and_return(Parser::I18n::Language['en'])
+        s1.stub!(:language).and_return(Parser::NaturalLanguage.get(nil, 'en'))
+        s2.stub!(:language).and_return(Parser::NaturalLanguage.get(nil, 'en'))
         c = StepCollection.new([s1, s2])
         actual_keywords = c.step_invocations.map{|i| i.actual_keyword}
         actual_keywords.should == %w{Given Given}