aslakhellesoy-cucumber 0.3.96 → 0.3.97

data/lib/cucumber/platform.rb

@@ -4,7 +4,6 @@ require 'rbconfig'
 require 'yaml'
 
 module Cucumber
-  # TODO: Move these constants and the file to Language. Update wiki
   LANGUAGE_FILE = File.expand_path(File.dirname(__FILE__) + '/languages.yml')
   LANGUAGES     = YAML.load_file(LANGUAGE_FILE)
   BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
@@ -17,7 +16,7 @@ module Cucumber
   RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
   RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
   
-  def self.file_mode(m)
+  def self.file_mode(m) #:nodoc:
     RUBY_1_9 ? "#{m}:UTF-8" : m
   end
 end

data/lib/cucumber/py_support/py_dsl.py

@@ -0,0 +1,8 @@
+def Given(s):
+  register_rb_step_definition(s)
+  
+def register_rb_step_definition(s):
+  print "REGGED"
+  
+def set_py_language(py_language):
+  print "YAY"

data/lib/cucumber/py_support/py_language.py

@@ -0,0 +1,2 @@
+import py_dsl
+

data/lib/cucumber/py_support/py_language.rb

@@ -0,0 +1,68 @@
+require 'rubypython'
+
+module Cucumber
+  module PySupport
+    class PyLanguage
+#      include LanguageSupport::LanguageMethods
+
+      def initialize(step_mother)
+        @python_path = ENV['PYTHONPATH'] ? ENV['PYTHONPATH'].split(':') : []
+        add_to_python_path(File.dirname(__FILE__))
+
+        RubyPython.start
+        at_exit{RubyPython.stop}
+
+        import(File.dirname(__FILE__) + '/py_language.py')
+      end
+
+      def alias_adverbs(adverbs)
+      end
+
+      def step_definitions_for(py_file)
+        mod = import(py_file)
+      end
+
+      def snippet_text(step_keyword, step_name, multiline_arg_class = nil)
+        "python snippet: #{step_keyword}, #{step_name}"
+      end
+
+      protected
+
+      def begin_scenario
+      end
+
+      def end_scenario
+      end
+
+      private
+
+      def import(path)
+        modname = File.basename(path)[0...-File.extname(path).length]
+        begin
+          mod = RubyPython.import(modname)
+        rescue PythonError => e
+          e.message << "Couldn't load #{path}\nConsider adding #{File.expand_path(File.dirname(path))} to your PYTHONPATH"
+          raise e
+        end
+      end
+
+      def add_to_python_path(dir)
+        dir = File.expand_path(dir)
+        @python_path.unshift(dir)
+        @python_path.uniq!
+        ENV['PYTHONPATH'] = @python_path.join(':')
+      end
+    end
+  end
+end
+
+class String #:nodoc:
+  # RubyPython incorrectly to expects String#end_with? to exist.
+  unless defined? end_with? # 1.9
+    def end_with?(str) #:nodoc:
+      str = str.to_str
+      tail = self[-str.length, str.length]
+      tail == str      
+    end
+  end
+end

data/lib/cucumber/rails/world.rb

@@ -23,7 +23,8 @@ $__cucumber_toplevel = self
 
 module Cucumber #:nodoc:
   module Rails
-    # All scenarios will execute in the context of a new instance of World.
+    # 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

data/lib/cucumber/rake/task.rb

@@ -8,7 +8,7 @@ module Cucumber
     #
     #   Cucumber::Rake::Task.new
     #
-    # This will create a task named 'cucumber' described as 'Run Cucumber features'. 
+    # 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:
@@ -82,10 +82,10 @@ module Cucumber
         end
       end
 
-      LIB = File.expand_path(File.dirname(__FILE__) + '/../..') # :nodoc:
+      LIB = File.expand_path(File.dirname(__FILE__) + '/../..') #:nodoc:
 
       # TODO: remove depreated accessors for 0.4.0
-      def self.deprecate_accessor(attribute) # :nodoc:
+      def self.deprecate_accessor(attribute) #:nodoc:
         attr_reader attribute
         class_eval <<-EOF, __FILE__, __LINE__ + 1
           def #{attribute}=(value)
@@ -133,7 +133,9 @@ module Cucumber
         @rcov_opts = String === opts ? opts.split(' ') : opts
       end
 
-      # Whether or not to fork a new ruby interpreter. Defaults to true.
+      # 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.
@@ -165,14 +167,14 @@ module Cucumber
         define_task
       end
 
-      def define_task # :nodoc:
+      def define_task #:nodoc:
         desc @desc
         task @task_name do
           runner.run
         end
       end
 
-      def runner(task_args = nil) # :nodoc:
+      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)
@@ -183,11 +185,11 @@ module Cucumber
         end
       end
 
-      def cucumber_opts_with_profile # :nodoc:
+      def cucumber_opts_with_profile #:nodoc:
         @profile ? [cucumber_opts, '--profile', @profile] : cucumber_opts
       end
 
-      def feature_files(task_args = nil) # :nodoc:
+      def feature_files(task_args = nil) #:nodoc:
         if ENV['FEATURE']
           FileList[ ENV['FEATURE'] ]
         else
@@ -199,7 +201,7 @@ module Cucumber
         end
       end
 
-      def step_files(task_args = nil) # :nodoc:
+      def step_files(task_args = nil) #:nodoc:
         if ENV['STEPS']
           FileList[ ENV['STEPS'] ]
         else
@@ -222,14 +224,14 @@ module Cucumber
         super(task_name, desc)
       end
 
-      def define_task # :nodoc:
+      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:
+      def feature_files(task_arguments) #:nodoc:
         FileList[File.join("features", "**", "#{task_arguments[:feature_name]}.feature")]
       end
 

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -7,11 +7,23 @@ module Cucumber
     # object.
     module RbDsl
       class << self
-        attr_accessor :step_mother, :rb_language
+        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.
@@ -33,38 +45,38 @@ module Cucumber
       #    World(MyModule)
       #
       def World(*world_modules, &proc)
-        RbDsl.rb_language.build_world_factory(*world_modules, &proc)
+        RbDsl.build_rb_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>).
+      # 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.step_mother.register_hook(:before, RbHook.new(RbDsl.rb_language, 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.step_mother.register_hook(:after, RbHook.new(RbDsl.rb_language, 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.step_mother.register_hook(:after_step, RbHook.new(RbDsl.rb_language, tag_names, proc))
+        RbDsl.register_rb_hook('after_step', tag_names, proc)
       end
 
-      # Registers a new Ruby StepDefinition.
-      # This method is aliased
+      # 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>
+      # 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))
+        RbDsl.register_rb_step_definition(regexp, proc)
       end
     end
   end

data/lib/cucumber/rb_support/rb_hook.rb

@@ -1,8 +1,7 @@
 module Cucumber
   module RbSupport
+    # Wrapper for Before, After and AfterStep hooks
     class RbHook
-      include LanguageSupport::HookMethods
-
       attr_reader :tag_names
       
       def initialize(rb_language, tag_names, proc)

data/lib/cucumber/rb_support/rb_language.rb

@@ -1,63 +1,57 @@
 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::StepMother#World RDoc\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, :step_mother
+      attr_reader :current_world
       
       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)
+
+      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
-          require step_def_file
+          load_code_file(code_file)
+          step_definitions
         rescue LoadError => e
-          e.message << "\nFailed to load #{step_def_file}"
+          e.message << "\nFailed to load #{code_filr}"
           raise e
+        ensure
+          @step_definitions = nil
         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('/', '\/')
@@ -78,11 +72,41 @@ module Cucumber
         "#{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)
+      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
@@ -100,15 +124,15 @@ module Cucumber
       end
 
       def extend_world
-        @current_world.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(step_mother)
-        @current_world.__cucumber_step_mother = step_mother
+      def connect_world
+        @current_world.__cucumber_step_mother = @step_mother
       end
 
       def check_nil(o, proc)

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -3,54 +3,58 @@ 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
+  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"
+      class MissingProc < StandardError
+        def message
+          "Step definitions must always have a proc"
+        end
       end
-    end
 
-    attr_reader :proc
+      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}$") 
+      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
-      @rb_language, @regexp, @proc = rb_language, pattern, proc
-    end
 
-    def regexp
-      @regexp
-    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
+      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
-    end
 
-    def file_colon_line
-      @proc.file_colon_line
-    end
+      def file_colon_line
+        @proc.file_colon_line
+      end
     
-    def file
-      @file ||= file_colon_line.split(':')[0]
+      def file
+        @file ||= file_colon_line.split(':')[0]
+      end
     end
   end
 end