cucumber 0.3.95 → 0.3.96

data/spec/cucumber/parser/table_parser_spec.rb

@@ -6,7 +6,7 @@ module Cucumber
   module Parser
     describe 'Tables' do
       before do
-        @parser = I18n::EnglishParser.new
+        @parser = NaturalLanguage.get(StepMother.new, 'en').parser
       end
       
       def parse(text)

data/spec/cucumber/step_definition_spec.rb

@@ -2,72 +2,73 @@ require File.dirname(__FILE__) + '/../spec_helper'
 
 require 'cucumber/ast'
 require 'cucumber/step_mother'
-require 'cucumber/step_definition'
+require 'cucumber/rb_support/rb_language'
 
 module Cucumber
-  describe StepDefinition do
-    before do
-      extend StepMother
-      @world = new_world!
+  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.begin_scenario
+
       $inside = nil
     end
 
     it "should allow calling of other steps" do
-      Given /Outside/ do
+      @dsl.Given /Outside/ do
         Given "Inside"
       end
-      Given /Inside/ do
+      @dsl.Given /Inside/ do
         $inside = true
       end
 
-      step_match("Outside").invoke(@world, nil)
+      @step_mother.step_match("Outside").invoke(nil)
       $inside.should == true
     end
 
     it "should allow calling of other steps with inline arg" do
-      Given /Outside/ do
+      @dsl.Given /Outside/ do
         Given "Inside", Ast::Table.new([['inside']])
       end
-      Given /Inside/ do |table|
+      @dsl.Given /Inside/ do |table|
         $inside = table.raw[0][0]
       end
 
-      step_match("Outside").invoke(@world, nil)
+      @step_mother.step_match("Outside").invoke(nil)
       $inside.should == 'inside'
     end
 
     it "should raise Undefined when inside step is not defined" do
-      Given /Outside/ do
+      @dsl.Given /Outside/ do
         Given 'Inside'
       end
 
-      step = mock('Step')
-      step.should_receive(:exception=)
       lambda do
-        @world.__cucumber_current_step = step
-        step_match('Outside').invoke(@world, nil)
+        @step_mother.step_match('Outside').invoke(nil)
       end.should raise_error(Undefined, 'Undefined step: "Inside"')
     end
 
     it "should allow forced pending" do
-      Given /Outside/ do
+      @dsl.Given /Outside/ do
         pending("Do me!")
       end
 
       lambda do
-        step_match("Outside").invoke(@world, nil)
+        @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')
-      self.visitor = v
-      world = new_world!
-      Given /Loud/ do
+      @step_mother.visitor = v
+      @dsl.Given /Loud/ do
         announce 'wasup'
       end
-      step_match("Loud").invoke(world, nil)
+      @step_mother.step_match("Loud").invoke(nil)
     end
     
     def unindented(s)
@@ -75,7 +76,7 @@ module Cucumber
     end
     
     it "should recognise quotes in name and make according regexp" do
-      StepDefinition.snippet_text('Given', 'A "first" arg').should == unindented(%{
+      @rb.snippet_text('Given', 'A "first" arg').should == unindented(%{
         Given /^A "([^\\"]*)" arg$/ do |arg1|
           pending
         end
@@ -83,7 +84,7 @@ module Cucumber
     end
 
     it "should recognise several quoted words in name and make according regexp and args" do
-      StepDefinition.snippet_text('Given', 'A "first" and "second" arg').should == unindented(%{
+      @rb.snippet_text('Given', 'A "first" and "second" arg').should == unindented(%{
         Given /^A "([^\\"]*)" and "([^\\"]*)" arg$/ do |arg1, arg2|
           pending
         end
@@ -91,7 +92,7 @@ module Cucumber
     end
 
     it "should not use quote group when there are no quotes" do
-      StepDefinition.snippet_text('Given', 'A first arg').should == unindented(%{
+      @rb.snippet_text('Given', 'A first arg').should == unindented(%{
         Given /^A first arg$/ do
           pending
         end

data/spec/cucumber/step_mother_spec.rb

@@ -1,34 +1,40 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
-require 'cucumber/step_mother'
+require 'cucumber'
+require 'cucumber/rb_support/rb_language'
 
 module Cucumber
   describe StepMother do
     before do
-      @step_mother = Object.new
-      @step_mother.extend(StepMother)
+      @dsl = Object.new
+      @dsl.extend(RbSupport::RbDsl)
+
+      @step_mother = StepMother.new
+      @step_mother.load_natural_language('en')
+      @rb = @step_mother.load_programming_language('rb')
+
       @visitor = mock('Visitor')
     end
 
     it "should format step names" do
-      @step_mother.Given(/it (.*) in (.*)/) do |what, month|
+      @dsl.Given(/it (.*) in (.*)/) do |what, month|
       end
-      @step_mother.Given(/nope something else/) do |what, month|
+      @dsl.Given(/nope something else/) do |what, month|
       end
       format = @step_mother.step_match("it snows in april").format_args("[%s]")
       format.should == "it [snows] in [april]"
     end
 
     it "should raise Ambiguous error with guess hint when multiple step definitions match" do
-      @step_mother.Given(/Three (.*) mice/) {|disability|}
-      @step_mother.Given(/Three blind (.*)/) {|animal|}
+      @dsl.Given(/Three (.*) mice/) {|disability|}
+      @dsl.Given(/Three blind (.*)/) {|animal|}
 
       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:23:in `/Three (.*) mice/'
-spec/cucumber/step_mother_spec.rb:24:in `/Three blind (.*)/'
+spec/cucumber/step_mother_spec.rb:29:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:30:in `/Three blind (.*)/'
 
 You can run again with --guess to make Cucumber be more smart about it
 })
@@ -36,23 +42,23 @@ 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}
-      @step_mother.Given(/Three (.*) mice/) {|disability|}
-      @step_mother.Given(/Three cute (.*)/) {|animal|}
+      @dsl.Given(/Three (.*) mice/) {|disability|}
+      @dsl.Given(/Three cute (.*)/) {|animal|}
 
       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:39:in `/Three (.*) mice/'
-spec/cucumber/step_mother_spec.rb:40:in `/Three cute (.*)/'
+spec/cucumber/step_mother_spec.rb:45:in `/Three (.*) mice/'
+spec/cucumber/step_mother_spec.rb:46:in `/Three cute (.*)/'
 
 })
     end
 
     it "should not raise Ambiguous error when multiple step definitions match, but --guess is enabled" do
       @step_mother.options = {:guess => true}
-      @step_mother.Given(/Three (.*) mice/) {|disability|}
-      @step_mother.Given(/Three (.*)/) {|animal|}
+      @dsl.Given(/Three (.*) mice/) {|disability|}
+      @dsl.Given(/Three (.*)/) {|animal|}
 
       lambda do
         @step_mother.step_match("Three blind mice")
@@ -61,23 +67,23 @@ spec/cucumber/step_mother_spec.rb:40:in `/Three cute (.*)/'
     
     it "should pick right step definition when --guess is enabled and equal number of capture groups" do
       @step_mother.options = {:guess => true}
-      right = @step_mother.Given(/Three (.*) mice/) {|disability|}
-      wrong = @step_mother.Given(/Three (.*)/) {|animal|}
+      right = @dsl.Given(/Three (.*) mice/) {|disability|}
+      wrong = @dsl.Given(/Three (.*)/) {|animal|}
       @step_mother.step_match("Three blind mice").step_definition.should == right
     end
     
     it "should pick right step definition when --guess is enabled and unequal number of capture groups" do
       @step_mother.options = {:guess => true}
-      right = @step_mother.Given(/Three (.*) mice ran (.*)/) {|disability|}
-      wrong = @step_mother.Given(/Three (.*)/) {|animal|}
+      right = @dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+      wrong = @dsl.Given(/Three (.*)/) {|animal|}
       @step_mother.step_match("Three blind mice ran far").step_definition.should == right
     end
 
     it "should pick most specific step definition when --guess is enabled and unequal number of capture groups" do
       @step_mother.options = {:guess => true}
-      general       = @step_mother.Given(/Three (.*) mice ran (.*)/) {|disability|}
-      specific      = @step_mother.Given(/Three blind mice ran far/) {}
-      more_specific = @step_mother.Given(/^Three blind mice ran far$/) {}
+      general       = @dsl.Given(/Three (.*) mice ran (.*)/) {|disability|}
+      specific      = @dsl.Given(/Three blind mice ran far/) {}
+      more_specific = @dsl.Given(/^Three blind mice ran far$/) {}
       @step_mother.step_match("Three blind mice ran far").step_definition.should == more_specific
     end
     
@@ -88,28 +94,28 @@ spec/cucumber/step_mother_spec.rb:40:in `/Three cute (.*)/'
     end
 
     it "should raise Redundant error when same regexp is registered twice" do
-      @step_mother.Given(/Three (.*) mice/) {|disability|}
+      @dsl.Given(/Three (.*) mice/) {|disability|}
       lambda do
-        @step_mother.Given(/Three (.*) mice/) {|disability|}
+        @dsl.Given(/Three (.*) mice/) {|disability|}
       end.should raise_error(Redundant)
     end
 
     # http://railsforum.com/viewtopic.php?pid=93881
     it "should not raise Redundant unless it's really redundant" do
-      @step_mother.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
-      @step_mother.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
+      @dsl.Given(/^(.*) (.*) user named '(.*)'$/) {|a,b,c|}
+      @dsl.Given(/^there is no (.*) user named '(.*)'$/) {|a,b|}
     end
 
     it "should raise an error if the world is nil" do
-      @step_mother.World do
+      @dsl.World do
       end
 
       begin
         @step_mother.before_and_after(nil) {}
         raise "Should fail"
-      rescue NilWorld => e
+      rescue RbSupport::NilWorld => e
         e.message.should == "World procs should never return nil"
-        e.backtrace.should == ["spec/cucumber/step_mother_spec.rb:104:in `World'"]
+        e.backtrace.should == ["spec/cucumber/step_mother_spec.rb:110:in `World'"]
       end
     end
 
@@ -123,25 +129,24 @@ spec/cucumber/step_mother_spec.rb:40:in `/Three cute (.*)/'
     end
 
     it "should implicitly extend world with modules" do
-      @step_mother.World(ModuleOne, ModuleTwo)
-
-      w = @step_mother.__send__(:new_world!)
-      class << w
+      @dsl.World(ModuleOne, ModuleTwo)
+      @step_mother.begin_scenario
+      class << @rb.current_world
         included_modules.index(ModuleOne).should_not == nil
         included_modules.index(ModuleTwo).should_not == nil
       end
-      w.class.should == Object
+      @rb.current_world.class.should == Object
     end
 
     it "should raise error when we try to register more than one World proc" do
-      @step_mother.World { Hash.new }
+      @dsl.World { Hash.new }
       lambda do
-        @step_mother.World { Array.new }
-      end.should raise_error(MultipleWorld, %{You can only pass a proc to #World once, but it's happening
+        @dsl.World { Array.new }
+      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:137:in `World'
-spec/cucumber/step_mother_spec.rb:139:in `World'
+spec/cucumber/step_mother_spec.rb:142:in `World'
+spec/cucumber/step_mother_spec.rb:144:in `World'
 
 Use Ruby modules instead to extend your worlds. See the Cucumber::StepMother#World RDoc
 or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
@@ -150,8 +155,8 @@ or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
     end
 
     it "should find before hooks" do
-      fish = @step_mother.Before('@fish'){}
-      meat = @step_mother.Before('@meat'){}
+      fish = @dsl.Before('@fish'){}
+      meat = @dsl.Before('@meat'){}
       
       scenario = mock('Scenario')
       scenario.should_receive(:accept_hook?).with(fish).and_return(true)

data/spec/cucumber/world/pending_spec.rb

@@ -1,13 +1,13 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/rb_support/rb_language'
 
 module Cucumber
-  module StepMother
     describe 'Pending' do
 
       before(:each) do
-        @step_mom = Object.new
-        @step_mom.extend(StepMother)
-        @world = @step_mom.__send__(:new_world!)
+        l = RbSupport::RbLanguage.new(StepMother.new)
+        l.begin_scenario
+        @world = l.current_world
       end
 
       it 'should raise a Pending if no block is supplied' do
@@ -43,5 +43,4 @@ module Cucumber
       end
 
     end
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: cucumber
 version: !ruby/object:Gem::Version 
-  version: 0.3.95
+  version: 0.3.96
 platform: ruby
 authors: 
 - "Aslak Helles\xC3\xB8y"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-08-13 00:00:00 +02:00
+date: 2009-08-20 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -388,7 +388,7 @@ files:
 - lib/cucumber/cli/main.rb
 - lib/cucumber/cli/options.rb
 - lib/cucumber/cli/profile_loader.rb
-- lib/cucumber/cli/rb_step_def_loader.rb
+- lib/cucumber/constantize.rb
 - lib/cucumber/core_ext/exception.rb
 - lib/cucumber/core_ext/instance_exec.rb
 - lib/cucumber/core_ext/proc.rb
@@ -413,12 +413,15 @@ files:
 - lib/cucumber/formatter/unicode.rb
 - lib/cucumber/formatter/usage.rb
 - lib/cucumber/formatters/unicode.rb
+- lib/cucumber/language_support/hook_methods.rb
+- lib/cucumber/language_support/language_methods.rb
+- lib/cucumber/language_support/step_definition_methods.rb
 - lib/cucumber/languages.yml
 - lib/cucumber/parser.rb
 - lib/cucumber/parser/feature.rb
 - lib/cucumber/parser/feature.tt
 - lib/cucumber/parser/i18n.tt
-- lib/cucumber/parser/i18n/language.rb
+- lib/cucumber/parser/natural_language.rb
 - lib/cucumber/parser/table.rb
 - lib/cucumber/parser/table.tt
 - lib/cucumber/parser/treetop_ext.rb
@@ -426,8 +429,11 @@ files:
 - lib/cucumber/rails/rspec.rb
 - lib/cucumber/rails/world.rb
 - lib/cucumber/rake/task.rb
+- lib/cucumber/rb_support/rb_dsl.rb
+- lib/cucumber/rb_support/rb_hook.rb
+- lib/cucumber/rb_support/rb_language.rb
+- lib/cucumber/rb_support/rb_step_definition.rb
 - lib/cucumber/rspec_neuter.rb
-- lib/cucumber/step_definition.rb
 - lib/cucumber/step_match.rb
 - lib/cucumber/step_mother.rb
 - lib/cucumber/version.rb

data/lib/cucumber/cli/rb_step_def_loader.rb

@@ -1,14 +0,0 @@
-module Cucumber
-  module Cli
-    class RbStepDefLoader
-      def load_step_def_file(main, step_def_file)
-        begin
-          require step_def_file
-        rescue LoadError => e
-          e.message << "\nFailed to load #{step_def_file}"
-          raise e
-        end
-      end
-    end
-  end
-end

data/lib/cucumber/parser/i18n/language.rb

@@ -1,87 +0,0 @@
-module Cucumber
-  module Parser
-    module I18n
-      class Language
-        KEYWORD_KEYS = %w{name native encoding feature background scenario scenario_outline examples given when then but}
-
-        class << self
-          LANGUAGES = Hash.new{|h,k| h[k] = Language.new(k)}
-          
-          def [](key)
-            LANGUAGES[key]
-          end
-
-          def alias_step_definitions(keywords) #:nodoc:
-            all_keywords = %w{given when then and but}.map{|keyword| keywords[keyword].split('|')}.flatten
-            alias_steps(all_keywords)
-          end
-
-          # Sets up additional method aliases for Given, When and Then.
-          # This does *not* affect how feature files are parsed. If you
-          # want to create aliases in the parser, you have to do this in
-          # languages.yml. For example:
-          #
-          # and: And|With
-          def alias_steps(keywords)
-            keywords.each do |adverb|
-              StepMother.alias_adverb(adverb)
-              World.alias_adverb(adverb)
-            end
-          end
-        end
-
-        alias_step_definitions(Cucumber::LANGUAGES['en'])
-
-        def initialize(lang)
-          @keywords = Cucumber::LANGUAGES[lang]
-          raise "Language not supported: #{lang.inspect}" if @keywords.nil?
-          @keywords['grammar_name'] = @keywords['name'].gsub(/\s/, '')
-        end
-        
-        def parser
-          return @parser if @parser
-          i18n_tt = File.expand_path(File.dirname(__FILE__) + '/../i18n.tt')
-          template = File.open(i18n_tt, Cucumber.file_mode('r')).read
-          erb = ERB.new(template)
-          grammar = erb.result(binding)
-          Treetop.load_from_string(grammar)
-          self.class.alias_step_definitions(@keywords)
-          @parser = Parser::I18n.const_get("#{@keywords['grammar_name']}Parser").new
-          def @parser.inspect
-            "#<#{self.class.name}>"
-          end
-          @parser
-        end
-
-        def parse(source, path, filter)
-          feature = parser.parse_or_fail(source, path, filter)
-          feature.language = self if feature
-          feature
-        end
-
-        def keywords(key, raw=false)
-          return @keywords[key] if raw
-          return nil unless @keywords[key]
-          values = @keywords[key].split('|')
-          values.map{|value| "'#{value}'"}.join(" / ")
-        end
-
-        def incomplete?
-          KEYWORD_KEYS.detect{|key| @keywords[key].nil?}
-        end
-
-        def scenario_keyword
-          @keywords['scenario'].split('|')[0] + ':'
-        end
-
-        def but_keywords
-          @keywords['but'].split('|')
-        end
-
-        def and_keywords
-          @keywords['and'].split('|')
-        end
-      end
-    end
-  end
-end