cucumber 0.3.95 → 0.3.96

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -0,0 +1,73 @@
+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_accessor :step_mother, :rb_language
+        
+        def alias_adverb(adverb)
+          alias_method adverb, :register_rb_step_definition
+        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.rb_language.build_world_factory(*world_modules, &proc)
+      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)
+        RbDsl.step_mother.register_hook(:before, RbHook.new(RbDsl.rb_language, tag_names, proc))
+      end
+
+      def After(*tag_names, &proc)
+        RbDsl.step_mother.register_hook(:after, RbHook.new(RbDsl.rb_language, tag_names, proc))
+      end
+
+      def AfterStep(*tag_names, &proc)
+        RbDsl.step_mother.register_hook(:after_step, RbHook.new(RbDsl.rb_language, tag_names, 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.
+      #
+      # 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_rb_step_definition(regexp, &proc)
+        RbDsl.step_mother.register_step_definition(RbStepDefinition.new(RbDsl.rb_language, regexp, &proc))
+      end
+    end
+  end
+end
+
+extend(Cucumber::RbSupport::RbDsl)

data/lib/cucumber/rb_support/rb_hook.rb

@@ -0,0 +1,19 @@
+module Cucumber
+  module RbSupport
+    class RbHook
+      include LanguageSupport::HookMethods
+
+      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, scenario)
+        @rb_language.current_world.cucumber_instance_exec(false, location, scenario, &@proc)
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_language.rb

@@ -0,0 +1,129 @@
+require 'cucumber/rb_support/rb_dsl'
+require 'cucumber/rb_support/rb_step_definition'
+
+module Cucumber
+  module RbSupport
+    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
+
+    class RbLanguage
+      include LanguageSupport::LanguageMethods
+      attr_reader :current_world, :step_mother
+      
+      def initialize(step_mother)
+        @step_mother = step_mother
+        RbDsl.step_mother = step_mother
+        RbDsl.rb_language = self
+      end
+      
+      def load_step_def_file(step_def_file)
+        begin
+          require step_def_file
+        rescue LoadError => e
+          e.message << "\nFailed to load #{step_def_file}"
+          raise e
+        end
+      end
+      
+      def build_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
+
+      def begin_scenario
+        create_world
+        extend_world
+        connect_world(@step_mother)
+      end
+
+      def end_scenario
+        @current_world = nil
+      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 alias_adverbs(adverbs)
+        adverbs.each do |adverb|
+          RbDsl.alias_adverb(adverb)
+          World.alias_adverb(adverb)
+        end
+      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(World)
+        @current_world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+        (@world_modules || []).each do |mod|
+          @current_world.extend(mod)
+        end
+      end
+
+      def connect_world(step_mother)
+        @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,56 @@
+require 'cucumber/step_match'
+require 'cucumber/core_ext/string'
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  # 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 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

data/lib/cucumber/step_match.rb

@@ -10,10 +10,10 @@ module Cucumber
       @formatted_step_name
     end
 
-    def invoke(world, multiline_arg)
+    def invoke(multiline_arg)
       all_args = @args.dup
       all_args << multiline_arg if multiline_arg
-      @step_definition.invoke(world, all_args)
+      @step_definition.invoke(all_args)
     end
 
     def format_args(format = lambda{|a| a})

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)