kosmas58-cucumber 0.3.96 → 0.3.97

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

@@ -25,6 +25,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 ***"
     

data/rails_generators/cucumber/templates/en/webrat_steps.rb

@@ -27,6 +27,10 @@ When /^I fill in "([^\"]*)" with "([^\"]*)"$/ do |field, value|
   fill_in(field, :with => value) 
 end
 
+When /^I fill in "([^\"]*)" for "([^\"]*)"$/ do |value, field|
+  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:

data/spec/cucumber/ast/background_spec.rb

@@ -10,7 +10,7 @@ module Cucumber
         extend(RbSupport::RbDsl)
         @step_mother = StepMother.new
         @step_mother.load_natural_language('en')
-        @step_mother.load_programming_language('rb')
+        @rb = @step_mother.load_programming_language('rb')
 
         $x = $y = nil
         Before do
@@ -19,12 +19,19 @@ module Cucumber
         Given /y is (\d+)/ do |n|
           $y = $x * n.to_i
         end
+
+        register
+
         @visitor = Visitor.new(@step_mother)
         @visitor.options = {}
 
         @feature = mock('feature', :visit? => true).as_null_object
       end
 
+      def register
+        @step_mother.register_step_definitions(@rb.step_definitions)
+      end
+
       it "should execute Before blocks before background steps" do
         background = Background.new(
           comment=Comment.new(''),

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -41,6 +41,7 @@ module Cucumber
           ],
           [
             [
+              Comment.new("#Mmmm... cucumbers\n"),
               24,
               'Examples:',
               'First table',

data/spec/cucumber/ast/table_spec.rb

@@ -285,6 +285,16 @@ module Cucumber
             |     aslak |     true |
           }
         end
+
+        it "should not allow mappings that match more than 1 column" do
+          t1 = Table.new([
+            ['Cuke',  'Duke'],
+            ['Foo', 'Bar']
+          ])
+          lambda do
+            t1.map_headers!(/uk/ => 'u')
+          end.should raise_error(%{2 headers matched /uk/: ["Cuke", "Duke"]})
+        end
         
         describe "raising" do
           before do

data/spec/cucumber/cli/options_spec.rb

@@ -46,7 +46,7 @@ module Cli
 
       context '-r or --require' do
         it "collects all specified files into an array" do
-          after_parsing ('--require some_file.rb -r another_file.rb') do
+          after_parsing('--require some_file.rb -r another_file.rb') do
             options[:require].should == ['some_file.rb', 'another_file.rb']
           end
         end

data/spec/cucumber/parser/feature_parser_spec.rb

@@ -349,6 +349,10 @@ Given I am a step
         it "should parse scenario_outline" do
           parse_file("scenario_outline.feature")
         end
+
+        it "should parse comments" do
+          parse_file("with_comments.feature")
+        end
       end
 
       describe "Filtering" do

data/spec/cucumber/rb_support/rb_step_definition_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'cucumber/ast'
+require 'cucumber/step_mother'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module RbSupport
+    describe RbStepDefinition do
+      before do      
+        @step_mother = StepMother.new
+        @step_mother.load_natural_language('en')
+        @rb = @step_mother.load_programming_language('rb')
+        @dsl = Object.new 
+        @dsl.extend RbSupport::RbDsl
+        @step_mother.before(nil)
+
+        $inside = nil
+      end
+      
+      def register
+        @step_mother.register_step_definitions(@rb.step_definitions)
+      end
+
+      it "should allow calling of other steps" do
+        @dsl.Given /Outside/ do
+          Given "Inside"
+        end
+        @dsl.Given /Inside/ do
+          $inside = true
+        end
+        register
+
+        @step_mother.step_match("Outside").invoke(nil)
+        $inside.should == true
+      end
+
+      it "should allow calling of other steps with inline arg" do
+        @dsl.Given /Outside/ do
+          Given "Inside", Ast::Table.new([['inside']])
+        end
+        @dsl.Given /Inside/ do |table|
+          $inside = table.raw[0][0]
+        end
+        register
+
+        @step_mother.step_match("Outside").invoke(nil)
+        $inside.should == 'inside'
+      end
+
+      it "should raise Undefined when inside step is not defined" do
+        @dsl.Given /Outside/ do
+          Given 'Inside'
+        end
+        register
+
+        lambda do
+          @step_mother.step_match('Outside').invoke(nil)
+        end.should raise_error(Undefined, 'Undefined step: "Inside"')
+      end
+
+      it "should allow forced pending" do
+        @dsl.Given /Outside/ do
+          pending("Do me!")
+        end
+        register
+
+        lambda do
+          @step_mother.step_match("Outside").invoke(nil)
+        end.should raise_error(Pending, "Do me!")
+      end
+
+      it "should allow announce" do
+        v = mock('visitor')
+        v.should_receive(:announce).with('wasup')
+        @step_mother.visitor = v
+        @dsl.Given /Loud/ do
+          announce 'wasup'
+        end
+        register
+        
+        @step_mother.step_match("Loud").invoke(nil)
+      end
+    
+      def unindented(s)
+        s.split("\n")[1..-2].join("\n").indent(-10)
+      end
+    
+      it "should recognise quotes in name and make according regexp" do
+        @rb.snippet_text('Given', 'A "first" arg').should == unindented(%{
+          Given /^A "([^\\"]*)" arg$/ do |arg1|
+            pending
+          end
+        })
+      end
+
+      it "should recognise several quoted words in name and make according regexp and args" do
+        @rb.snippet_text('Given', 'A "first" and "second" arg').should == unindented(%{
+          Given /^A "([^\\"]*)" and "([^\\"]*)" arg$/ do |arg1, arg2|
+            pending
+          end
+        })
+      end
+
+      it "should not use quote group when there are no quotes" do
+        @rb.snippet_text('Given', 'A first arg').should == unindented(%{
+          Given /^A first arg$/ do
+            pending
+          end
+        })
+      end
+    end
+  end
+end

data/spec/cucumber/step_mother_spec.rb

@@ -16,11 +16,17 @@ module Cucumber
       @visitor = mock('Visitor')
     end
 
+    def register
+      @step_mother.register_step_definitions(@rb.step_definitions)
+    end
+
     it "should format step names" do
       @dsl.Given(/it (.*) in (.*)/) do |what, month|
       end
       @dsl.Given(/nope something else/) do |what, month|
       end
+      register
+      
       format = @step_mother.step_match("it snows in april").format_args("[%s]")
       format.should == "it [snows] in [april]"
     end
@@ -28,13 +34,14 @@ module Cucumber
     it "should raise Ambiguous error with guess hint when multiple step definitions match" do
       @dsl.Given(/Three (.*) mice/) {|disability|}
       @dsl.Given(/Three blind (.*)/) {|animal|}
+      register
 
       lambda do
         @step_mother.step_match("Three blind mice")
       end.should raise_error(Ambiguous, %{Ambiguous match of "Three blind mice":
 
-spec/cucumber/step_mother_spec.rb:29:in `/Three (.*) mice/'
-spec/cucumber/step_mother_spec.rb:30:in `/Three blind (.*)/'
+spec/cucumber/step_mother_spec.rb:35:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:36:in `/Three blind (.*)/'
 
 You can run again with --guess to make Cucumber be more smart about it
 })
@@ -42,15 +49,17 @@ You can run again with --guess to make Cucumber be more smart about it
 
     it "should not show --guess hint when --guess is used" do
       @step_mother.options = {:guess => true}
+
       @dsl.Given(/Three (.*) mice/) {|disability|}
       @dsl.Given(/Three cute (.*)/) {|animal|}
+      register
 
       lambda do
         @step_mother.step_match("Three cute mice")
       end.should raise_error(Ambiguous, %{Ambiguous match of "Three cute mice":
 
-spec/cucumber/step_mother_spec.rb:45:in `/Three (.*) mice/'
-spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
+spec/cucumber/step_mother_spec.rb:53:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:54:in `/Three cute (.*)/'
 
 })
     end
@@ -59,6 +68,7 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
       @step_mother.options = {:guess => true}
       @dsl.Given(/Three (.*) mice/) {|disability|}
       @dsl.Given(/Three (.*)/) {|animal|}
+      register
 
       lambda do
         @step_mother.step_match("Three blind mice")
@@ -69,6 +79,8 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
       @step_mother.options = {:guess => true}
       right = @dsl.Given(/Three (.*) mice/) {|disability|}
       wrong = @dsl.Given(/Three (.*)/) {|animal|}
+      register
+
       @step_mother.step_match("Three blind mice").step_definition.should == right
     end
     
@@ -76,6 +88,8 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
       @step_mother.options = {:guess => true}
       right = @dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
       wrong = @dsl.Given(/Three (.*)/) {|animal|}
+      register
+
       @step_mother.step_match("Three blind mice ran far").step_definition.should == right
     end
 
@@ -84,6 +98,8 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
       general       = @dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
       specific      = @dsl.Given(/Three blind mice ran far/) {}
       more_specific = @dsl.Given(/^Three blind mice ran far$/) {}
+      register
+
       @step_mother.step_match("Three blind mice ran far").step_definition.should == more_specific
     end
     
@@ -97,6 +113,7 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
       @dsl.Given(/Three (.*) mice/) {|disability|}
       lambda do
         @dsl.Given(/Three (.*) mice/) {|disability|}
+        register
       end.should raise_error(Redundant)
     end
 
@@ -104,6 +121,7 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
     it "should not raise Redundant unless it's really redundant" do
       @dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
       @dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
+      register
     end
 
     it "should raise an error if the world is nil" do
@@ -115,7 +133,7 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
         raise "Should fail"
       rescue RbSupport::NilWorld => e
         e.message.should == "World procs should never return nil"
-        e.backtrace.should == ["spec/cucumber/step_mother_spec.rb:110:in `World'"]
+        e.backtrace.should == ["spec/cucumber/step_mother_spec.rb:128:in `World'"]
       end
     end
 
@@ -130,7 +148,7 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
 
     it "should implicitly extend world with modules" do
       @dsl.World(ModuleOne, ModuleTwo)
-      @step_mother.begin_scenario
+      @step_mother.before(nil)
       class << @rb.current_world
         included_modules.index(ModuleOne).should_not == nil
         included_modules.index(ModuleTwo).should_not == nil
@@ -145,10 +163,10 @@ spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
       end.should raise_error(RbSupport::MultipleWorld, %{You can only pass a proc to #World once, but it's happening
 in 2 places:
 
-spec/cucumber/step_mother_spec.rb:142:in `World'
-spec/cucumber/step_mother_spec.rb:144:in `World'
+spec/cucumber/step_mother_spec.rb:160:in `World'
+spec/cucumber/step_mother_spec.rb:162:in `World'
 
-Use Ruby modules instead to extend your worlds. See the Cucumber::StepMother#World RDoc
+Use Ruby modules instead to extend your worlds. See the Cucumber::RbSupport::RbDsl#World RDoc
 or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
 
 })
@@ -157,12 +175,13 @@ or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
     it "should find before hooks" do
       fish = @dsl.Before('@fish'){}
       meat = @dsl.Before('@meat'){}
+      register
       
       scenario = mock('Scenario')
       scenario.should_receive(:accept_hook?).with(fish).and_return(true)
       scenario.should_receive(:accept_hook?).with(meat).and_return(false)
       
-      @step_mother.hooks_for(:before, scenario).should == [fish]
+      @rb.hooks_for(:before, scenario).should == [fish]
     end
   end
 end