cucumber 0.3.96 → 0.3.97

data/lib/cucumber/rb_support/rb_world.rb

@@ -0,0 +1,93 @@
+module Cucumber
+  module RbSupport
+    # All steps are run in the context of an object that extends this module.
+    module RbWorld
+      class << self
+        def alias_adverb(adverb)
+          alias_method adverb, :__cucumber_invoke
+        end
+      end
+    
+      attr_writer :__cucumber_step_mother
+
+      # Call a step from within a step definition. This method is aliased to
+      # the same i18n as RbDsl.
+      def __cucumber_invoke(name, multiline_argument=nil) #:nodoc:
+        begin
+          step_match = @__cucumber_step_mother.step_match(name)
+          step_match.invoke(multiline_argument)
+        rescue Exception => e
+          e.nested! if Undefined === e
+          raise e
+        end
+      end
+
+      # 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.
+      # 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_step_mother.announce(announcement)
+      end
+
+      # Mark the matched step as pending.
+      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
+
+      # The default implementation of Object#inspect recursively
+      # traverses all instance variables and invokes inspect. 
+      # This can be time consuming if the object graph is large.
+      #
+      # This can cause unnecessary delays when certain exceptions 
+      # occur. For example, MRI internally invokes #inspect on an 
+      # object that raises a NoMethodError. (JRuby does not do this).
+      #
+      # A World object can have many references created by the user
+      # or frameworks (Rails), so to avoid long waiting times on
+      # such errors in World we define it to just return a simple String.
+      #
+      def inspect #:nodoc:
+        sprintf("#<%s:0x%x>", self.class, self.object_id)
+      end
+    end
+  end
+end

data/lib/cucumber/rspec_neuter.rb

@@ -1,11 +1,11 @@
 require 'optparse'
 
-module Spec
-  module Runner
+module Spec #:nodoc:
+  module Runner #:nodoc:
     # Neuters RSpec's option parser.
     # (RSpec's option parser tries to parse ARGV, which
     # will fail when running cucumber)
-    class OptionParser < ::OptionParser
+    class OptionParser < ::OptionParser #:nodoc:
       NEUTERED_RSPEC = Object.new
       def NEUTERED_RSPEC.method_missing(m, *args); self; end
       

data/lib/cucumber/step_match.rb

@@ -1,5 +1,5 @@
 module Cucumber
-  class StepMatch
+  class StepMatch #:nodoc:
     attr_reader :step_definition, :args
 
     def initialize(step_definition, step_name, formatted_step_name, args)
@@ -33,7 +33,7 @@ module Cucumber
     end
   end
   
-  class NoStepMatch
+  class NoStepMatch #:nodoc:
     attr_reader :step_definition, :name
 
     def initialize(step, name)

data/lib/cucumber/step_mother.rb

@@ -1,12 +1,12 @@
+require 'logger'
 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
+  # Raised when there is no matching StepDefinition for a step.
   class Undefined < StandardError
     attr_reader :step_name
 
@@ -28,7 +28,7 @@ module Cucumber
   class Pending < StandardError
   end
 
-  # Raised when a step matches 2 or more StepDefinition
+  # Raised when a step matches 2 or more StepDefinitions
   class Ambiguous < StandardError
     def initialize(step_name, step_definitions, used_guess)
       message = "Ambiguous match of \"#{step_name}\":\n\n"
@@ -49,27 +49,61 @@ module Cucumber
     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.
+  # This is the meaty part of Cucumber that ties everything together.
   class StepMother
     include Constantize
     
-    attr_writer :options, :visitor
+    attr_writer :options, :visitor, :log
 
     def initialize
+      @unsupported_programming_languages = []
       @programming_languages = []
       @language_map = {}
       load_natural_language('en')
     end
 
+    def load_plain_text_features(feature_files)
+      features = Ast::Features.new
+
+      log.debug("Features:\n")
+      feature_files.each do |f|
+        feature_file = FeatureFile.new(f)
+        feature = feature_file.parse(self, options)
+        if feature
+          features.add_feature(feature)
+          log.debug("  * #{f}\n")
+        end
+      end
+      log.debug("\n")
+      features
+    end
+
+    def load_code_files(step_def_files)
+      log.debug("Code:\n")
+      step_def_files.each do |step_def_file|
+        load_code_file(step_def_file)
+      end
+      log.debug("\n")
+    end
+
+    def load_code_file(step_def_file)
+      if programming_language = programming_language_for(step_def_file)
+        log.debug("  * #{step_def_file}\n")
+        step_definitions = programming_language.step_definitions_for(step_def_file)
+        register_step_definitions(step_definitions)
+      else
+        log.debug("  * #{step_def_file} [NOT SUPPORTED]\n")
+      end
+    end
+
+    def register_step_definitions(step_definitions)
+      step_definitions.each{|step_definition| register_step_definition(step_definition)}
+    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")
@@ -88,26 +122,16 @@ module Cucumber
       Parser::NaturalLanguage.get(self, lang)
     end
 
-    # 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
-
+    # Returns the options passed on the command line.
     def options
       @options ||= {}
     end
 
-    def step_visited(step)
+    def step_visited(step) #:nodoc:
       steps << step unless steps.index(step)
     end
-    
-    def steps(status = nil)
+
+    def steps(status = nil) #:nodoc:
       @steps ||= []
       if(status)
         @steps.select{|step| step.status == status}
@@ -116,11 +140,11 @@ module Cucumber
       end
     end
 
-    def announce(msg)
+    def announce(msg) #:nodoc:
       @visitor.announce(msg)
     end
 
-    def scenarios(status = nil)
+    def scenarios(status = nil) #:nodoc:
       @scenarios ||= []
       if(status)
         @scenarios.select{|scenario| scenario.status == status}
@@ -129,20 +153,7 @@ module Cucumber
       end
     end
 
-    def register_hook(phase, hook)
-      hooks[phase.to_sym] << hook
-      hook
-    end
-
-    def hooks
-      @hooks ||= Hash.new {|hash, phase| hash[phase] = []}
-    end
-
-    def hooks_for(phase, scenario)
-      hooks[phase.to_sym].select{|hook| scenario.accept_hook?(hook)}
-    end
-
-    def step_match(step_name, formatted_step_name=nil)
+    def step_match(step_name, formatted_step_name=nil) #:nodoc:
       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]
@@ -150,7 +161,7 @@ module Cucumber
       matches[0]
     end
 
-    def best_matches(step_name, step_matches)
+    def best_matches(step_name, step_matches) #:nodoc:
       no_groups      = step_matches.select {|step_match| step_match.args.length == 0}
       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 }
@@ -166,31 +177,31 @@ module Cucumber
       end
     end
     
-    def clear!
+    def clear! #:nodoc:
       step_definitions.clear
       hooks.clear
       steps.clear
       scenarios.clear
     end
 
-    def step_definitions
+    def step_definitions #:nodoc:
       @step_definitions ||= []
     end
 
-    def snippet_text(step_keyword, step_name, multiline_arg_class)
+    def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
       @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)
+    def before_and_after(scenario, skip_hooks=false) #:nodoc:
       before(scenario) unless skip_hooks
       yield scenario
       after(scenario) unless skip_hooks
       scenario_visited(scenario)
     end
 
-    def register_adverbs(adverbs)
+    def register_adverbs(adverbs) #:nodoc:
       @adverbs ||= []
       @adverbs += adverbs
       @adverbs.uniq!
@@ -198,22 +209,8 @@ module Cucumber
         programming_language.alias_adverbs(@adverbs)
       end
     end
-
-    def begin_scenario
-      return if options[:dry_run]
-      @programming_languages.each do |programming_language|
-        programming_language.begin_scenario
-      end
-    end
-
-    def end_scenario
-      return if options[:dry_run]
-      @programming_languages.each do |programming_language|
-        programming_language.end_scenario
-      end
-    end
     
-    def before(scenario)
+    def before(scenario) #:nodoc:
       return if options[:dry_run] || @current_scenario
       @current_scenario = scenario
       @programming_languages.each do |programming_language|
@@ -221,7 +218,7 @@ module Cucumber
       end
     end
     
-    def after(scenario)
+    def after(scenario) #:nodoc:
       @current_scenario = nil
       return if options[:dry_run]
       @programming_languages.each do |programming_language|
@@ -229,7 +226,7 @@ module Cucumber
       end
     end
     
-    def after_step
+    def after_step #:nodoc:
       return if options[:dry_run]
       @programming_languages.each do |programming_language|
         programming_language.execute_after_step(@current_scenario)
@@ -238,12 +235,41 @@ module Cucumber
     
     private
 
-    def max_step_definition_length
+    # 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
+
+    def programming_language_for(step_def_file) #:nodoc:
+      if ext = File.extname(step_def_file)[1..-1]
+        return nil if @unsupported_programming_languages.index(ext)
+        begin
+          load_programming_language(ext)
+        rescue LoadError
+          @unsupported_programming_languages << ext
+          nil
+        end
+      else
+        nil
+      end
+    end
+
+    def max_step_definition_length #:nodoc:
       @max_step_definition_length ||= step_definitions.map{|step_definition| step_definition.text_length}.max
     end
 
-    def scenario_visited(scenario)
+    def scenario_visited(scenario) #:nodoc:
       scenarios << scenario unless scenarios.index(scenario)
     end
+
+    def log
+      @log ||= Logger.new(STDOUT)
+    end
   end
 end

data/lib/cucumber/version.rb

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

data/lib/cucumber/webrat/element_locator.rb

@@ -55,7 +55,7 @@ module Webrat
   end
   
   module Locators
-    class ElementLocator < Locator
+    class ElementLocator < Locator #:nodoc:
       def locate
         Element.load(@session, table_element)
       end
@@ -77,11 +77,11 @@ module Webrat
     alias table_at element_at # Backwards compatibility with Cucumber
   end
   
-  module Methods
+  module Methods #:nodoc:
     delegate_to_session :element_at, :table_at
   end
   
-  class Session
+  class Session #:nodoc:
     def_delegators :current_scope, :element_at, :table_at
   end
 end

data/rails_generators/cucumber/templates/cucumber.rake

@@ -21,6 +21,8 @@ begin
   desc 'Alias for cucumber:ok'
   task :cucumber => 'cucumber:ok'
 
+  task :default => :cucumber
+
   task :features => :cucumber do
     STDERR.puts "*** The 'features' task is deprecated. See rake -T cucumber ***"
   end