aslakhellesoy-cucumber 0.3.101 → 0.3.101.2

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -1,5 +1,3 @@
-require 'cucumber/rb_support/rb_hook'
-
 module Cucumber
   module RbSupport
     # This module defines the methods you can use to define pure Ruby
@@ -21,6 +19,10 @@ module Cucumber
           @rb_language.register_rb_hook(phase, tag_names, proc)
         end
 
+        def register_rb_transform(regexp, proc)
+          @rb_language.register_rb_transform(regexp, proc)          
+        end
+
         def register_rb_step_definition(regexp, proc)
           @rb_language.register_rb_step_definition(regexp, proc)
         end
@@ -71,8 +73,8 @@ module Cucumber
       # the pattern contains captures then they will be yielded as arguments to the
       # provided proc. The return value of the proc is consequently yielded to the
       # step definition.
-      def Transform(*args, &proc)
-        StepMother.register_transform(*args, &proc)
+      def Transform(regexp, &proc)
+        RbDsl.register_rb_transform(regexp, proc)
       end
       
       # Registers a proc that will run after Cucumber is configured. You can register as 

data/lib/cucumber/rb_support/rb_language.rb

@@ -1,6 +1,8 @@
 require 'cucumber/rb_support/rb_dsl'
 require 'cucumber/rb_support/rb_world'
 require 'cucumber/rb_support/rb_step_definition'
+require 'cucumber/rb_support/rb_hook'
+require 'cucumber/rb_support/rb_transform'
 
 module Cucumber
   module RbSupport
@@ -82,6 +84,10 @@ module Cucumber
         add_hook(phase, RbHook.new(self, tag_names, proc))
       end
 
+      def register_rb_transform(regexp, proc)
+        add_transform(RbTransform.new(self, regexp, proc))
+      end
+
       def register_rb_step_definition(regexp, proc)
         add_step_definition(RbStepDefinition.new(self, regexp, proc))
       end
@@ -98,7 +104,7 @@ module Cucumber
       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
+        require code_file # This will cause self.add_step_definition, self.add_hook, and self.add_transform to be called from RbDsl
       end
 
       def begin_scenario
@@ -150,4 +156,4 @@ module Cucumber
       end
     end
   end
-end
+end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -23,7 +23,7 @@ module Cucumber
         end
       end
 
-      attr_reader :proc
+      attr_reader :proc, :regexp
 
       def initialize(rb_language, pattern, proc)
         raise MissingProc if proc.nil?
@@ -34,13 +34,10 @@ module Cucumber
         @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
+          args = @rb_language.execute_transforms(args)
           @rb_language.current_world.cucumber_instance_exec(true, regexp.inspect, *args, &@proc)
         rescue Cucumber::ArityMismatchError => e
           e.backtrace.unshift(self.backtrace_line)

data/lib/cucumber/rb_support/rb_transform.rb

@@ -0,0 +1,35 @@
+module Cucumber
+  module RbSupport
+    # A Ruby Transform holds a Regexp and a Proc, and is created
+    # by calling <tt>Transform in the <tt>support</tt> ruby files.
+    # See also RbDsl.
+    #
+    # Example:
+    #
+    #   Transform /^(\d+) cucumbers$/ do |cucumbers_string|
+    #     cucumbers_string.to_i
+    #   end
+    #
+    class RbTransform
+      class MissingProc < StandardError
+        def message
+          "Transforms must always have a proc with at least one argument"
+        end
+      end
+
+      attr_reader :proc, :regexp
+      
+      def initialize(rb_language, pattern, proc)
+        raise MissingProc if proc.nil? || proc.arity < 1
+        @rb_language, @regexp, @proc = rb_language, Regexp.new(pattern), proc        
+      end
+
+      def invoke(arg)
+        if matched = regexp.match(arg)
+          args = Array(matched.captures.empty? ? arg : matched.captures)
+          @rb_language.current_world.cucumber_instance_exec(true, regexp.inspect, *args, &@proc)
+        end        
+      end
+    end
+  end
+end

data/lib/cucumber/rb_support/rb_world.rb

@@ -7,6 +7,12 @@ module Cucumber
           alias_method adverb, :__cucumber_invoke
         end
       end
+
+      # Call a Transform with a string from another Transform definition
+      def Transform(arg)
+        rb = @__cucumber_step_mother.load_programming_language('rb')
+        rb.execute_transforms([arg]).first
+      end
     
       attr_writer :__cucumber_step_mother
 
@@ -90,4 +96,4 @@ module Cucumber
       end
     end
   end
-end
+end

data/lib/cucumber/step_match.rb

@@ -58,4 +58,4 @@ module Cucumber
       @step.text_length
     end
   end
-end
+end

data/lib/cucumber/step_mother.rb

@@ -50,9 +50,7 @@ module Cucumber
 
   # This is the meaty part of Cucumber that ties everything together.
   class StepMother
-    include Constantize    
-    @@transforms = []
-    StepArgumentTransform = Struct.new(:pattern, :transformer)
+    include Constantize
     attr_writer :options, :visitor, :log
 
     def initialize
@@ -61,32 +59,6 @@ module Cucumber
       @language_map = {}
       load_natural_language('en')
     end
-    
-    def self.register_transform(pattern, &transformer)
-      raise Cucumber::ArityMismatchError.new('Transform must be registered with at least a one-argument block') if !block_given? || transformer.arity < 1
-      @@transforms.unshift StepArgumentTransform.new(Regexp.new(pattern), transformer.to_proc)
-    end
-
-    def self.transform_arguments(step_args)
-      matched = nil
-      step_args.map do |step_arg|
-        if transform = @@transforms.detect {|t| matched = t.pattern.match(step_arg) if step_arg.is_a?(String) }          
-          if matched.captures.empty?
-            unless transform.transformer.arity == 1
-              raise Cucumber::ArityMismatchError.new("Transforms without Regexp captures only accept a single argument (the step argument)")
-            end
-            transform.transformer.call(step_arg)
-          else
-            if transform.transformer.arity != matched.captures.size
-              raise Cucumber::ArityMismatchError.new("Number of arguments in Transform (#{transform.transformer.arity}) does not match number of Regexp captures (#{matched.captures.size})")
-            end
-            transform.transformer.call(*matched.captures)
-          end
-        else
-          step_arg
-        end
-      end
-    end
 
     def load_plain_text_features(feature_files)
       features = Ast::Features.new
@@ -215,11 +187,16 @@ module Cucumber
     end
 
     def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+      load_programming_language('rb') if unknown_programming_language?
       @programming_languages.map do |programming_language|
         programming_language.snippet_text(step_keyword, step_name, multiline_arg_class)
       end.join("\n")
     end
 
+    def unknown_programming_language?
+      @programming_languages.empty?
+    end
+
     def before_and_after(scenario, skip_hooks=false) #:nodoc:
       before(scenario) unless skip_hooks
       yield scenario
@@ -263,8 +240,8 @@ module Cucumber
       @programming_languages.each do |programming_language|
         programming_language.after_configuration(configuration)
       end
-    end  
-    
+    end
+
     private
 
     # Registers a StepDefinition. This can be a Ruby StepDefintion,

data/lib/cucumber/version.rb

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

data/rails_generators/cucumber/templates/cucumber_environment.rb

@@ -18,8 +18,8 @@ config.action_mailer.delivery_method = :test
 config.gem 'cucumber',    :lib => false,        :version => '>=<%= cucumber_version %>' unless File.directory?(File.join(Rails.root, 'vendor/plugins/cucumber'))
 config.gem 'webrat',      :lib => false,        :version => '>=0.5.0' unless File.directory?(File.join(Rails.root, 'vendor/plugins/webrat'))
 <% if framework == :rspec -%>
-config.gem 'rspec',       :lib => false,        :version => '>=1.2.6' unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec'))
-config.gem 'rspec-rails', :lib => 'spec/rails', :version => '>=1.2.6' unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec-rails'))
+config.gem 'rspec',       :lib => false,        :version => '>=1.2.8' unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec'))
+config.gem 'rspec-rails', :lib => false,        :version => '>=1.2.7.1' unless File.directory?(File.join(Rails.root, 'vendor/plugins/rspec-rails'))
 <% end %>
 <% if spork? -%>
 config.gem 'spork',       :lib => false,        :version => '>=0.5.9' unless File.directory?(File.join(Rails.root, 'vendor/plugins/spork'))

data/rails_generators/cucumber/templates/env.rb

@@ -6,19 +6,12 @@ require 'cucumber/rails/world'
 # Comment out the next line if you don't want Cucumber Unicode support
 require 'cucumber/formatter/unicode'
 
-# Comment out the next line if you don't want transactions to
-# open/roll back around each scenario
-Cucumber::Rails.use_transactional_fixtures
-
-# Comment out the next line if you want Rails' own error handling
-# (e.g. rescue_action_in_public / rescue_responses / rescue_from)
-Cucumber::Rails.bypass_rescue
-
 require 'webrat'
 require 'cucumber/webrat/element_locator' # Lets you do table.diff!(element_at('#my_table_or_dl_or_ul_or_ol').to_table)
 
 Webrat.configure do |config|
   config.mode = :rails
+  config.open_error_files = false # Set to true if you want error pages to pop up in the browser
 end
 <% if framework == :rspec -%>
 

data/spec/cucumber/ast/feature_element_spec.rb

@@ -3,38 +3,39 @@ require 'cucumber/step_mother'
 require 'cucumber/ast'
 
 module Cucumber
-  describe FeatureElement do
-    include FeatureElement
+  module Ast
+    describe FeatureElement do
+      include FeatureElement
 
-    describe "with multiline names" do
-      it "should select the longest line as the text length" do
-        @keyword = "key"  
-        @name = "short\nvery longer\ntiny"
-        text_length.should == 11 + Ast::Step::INDENT - 1
-      end
+      describe "with multiline names" do
+        it "should select the longest line as the text length" do
+          @keyword = "key"  
+          @name = "short\nvery longer\ntiny"
+          text_length.should == 11 + Ast::Step::INDENT - 1
+        end
       
-      it "should add keyword to first lines length" do
-        @keyword = "key"  
-        @name = "short\nvery longer\ntiny"
+        it "should add keyword to first lines length" do
+          @keyword = "key"  
+          @name = "short\nvery longer\ntiny"
         
-        first_line_length.should == (@keyword.jlength) + (first_line_name_length = 5)
+          first_line_length.should == (@keyword.jlength) + (first_line_name_length = 5)
+        end
       end
-    end
     
-    describe "with empty name" do
-      it "should only return the length of the keyword" do
-        @name = ""
-        @keyword = "key"
+      describe "with empty name" do
+        it "should only return the length of the keyword" do
+          @name = ""
+          @keyword = "key"
         
-        text_length.should == 3
+          text_length.should == 3
+        end
       end
-    end
 
-    it "should support checking if its name matches a list of regexps" do
-      @name = 'test'
-      matches_scenario_names?([/es/]).should be_true
+      it "should support checking if its name matches a list of regexps" do
+        @name = 'test'
+        matches_scenario_names?([/es/]).should be_true
+      end
     end
-    
   end
 end
 

data/spec/cucumber/ast/scenario_outline_spec.rb

@@ -64,7 +64,7 @@ module Cucumber
 
       it "should pretty print" do
         require 'cucumber/formatter/pretty'
-        visitor = Formatter::Pretty.new(@step_mother, STDOUT, {:comment => true, :include_tags => {}, :exclude_tags => {}})
+        visitor = Formatter::Pretty.new(@step_mother, STDOUT, {:comment => true, :tag_names => {}})
         visitor.visit_feature_element(@scenario_outline)
       end
     end

data/spec/cucumber/cli/options_spec.rb

@@ -92,11 +92,8 @@ module Cli
       end
 
       context '-t TAGS --tags TAGS' do
-        it "removes the @ prefix" do
-          after_parsing('-t @foo,bar') { options[:include_tags].should == {'foo' => nil, 'bar' => nil} }
-        end
         it "designates tags prefixed with ~ as tags to be excluded" do
-          after_parsing('--tags ~@foo,bar') { options[:exclude_tags].should == {'foo' => nil} }
+          after_parsing('--tags ~@foo,@bar') { options[:tag_names].should == {'~@foo' => nil, '@bar' => nil} }
         end
       end
 
@@ -160,16 +157,10 @@ module Cli
           options[:require].should == %w[foo.rb features dog.rb]
         end
 
-        it "combines the include_tags of both" do
-          given_cucumber_yml_defined_as('baz' => %w[-t bar])
-          options.parse!(%w[--tags foo -p baz])
-          options[:include_tags].should == {'foo' => nil, 'bar' => nil}
-        end
-
-        it "combines the exclude_tags of both" do
-          given_cucumber_yml_defined_as('baz' => %w[-t ~bar])
-          options.parse!(%w[--tags ~foo -p baz])
-          options[:exclude_tags].should == {'foo' => nil, 'bar' => nil}
+        it "combines the tag names of both" do
+          given_cucumber_yml_defined_as('baz' => %w[-t @bar])
+          options.parse!(%w[--tags @foo -p baz])
+          options[:tag_names].should == {'@foo' => nil, '@bar' => nil}
         end
 
         it "only takes the paths from the original options, and disgregards the profiles" do

data/spec/cucumber/parser/feature_parser_spec.rb

@@ -68,8 +68,8 @@ Feature: hi
           parse("# My comment\n@hello @world Feature: hi\n").to_sexp.should ==
           [:feature, nil, "Feature: hi",
             [:comment, "# My comment\n"],
-            [:tag, "hello"],
-            [:tag, "world"]]
+            [:tag, "@hello"],
+            [:tag, "@world"]]
         end
 
         it "should not take the tags as part of a multiline name feature element" do
@@ -77,7 +77,7 @@ Feature: hi
           [:feature, nil, "Feature: hi",
            [:scenario, 2, "Scenario:", "test"], 
            [:scenario, 4, "Scenario:", "another", 
-             [:tag, "hello"]]]
+             [:tag, "@hello"]]]
         end
 
         it "should parse a file with tags on a scenario" do
@@ -94,13 +94,13 @@ Feature: hi
   Scenario: Second}).to_sexp.should ==
           [:feature, nil, "Feature: hi",
             [:comment, "# FC\n  "],
-            [:tag, "ft"],
+            [:tag, "@ft"],
             [:scenario, 6, 'Scenario:', 'First',
-              [:tag, "st1"], [:tag, "st2"],
+              [:tag, "@st1"], [:tag, "@st2"],
               [:step_invocation, 7, "Given", "Pepper"]
             ],
             [:scenario, 11, 'Scenario:', 'Second',
-              [:tag, "st3"], [:tag, "st4"], [:tag, "ST5"], [:tag, "#^%&ST6**!"]]]
+              [:tag, "@st3"], [:tag, "@st4"], [:tag, "@ST5"], [:tag, "@#^%&ST6**!"]]]
         end
       end
       

data/spec/cucumber/step_mother_spec.rb

@@ -186,96 +186,99 @@ or http://wiki.github.com/aslakhellesoy/cucumber/a-whole-new-world.
   end
 
   describe StepMother, "step argument transformations" do
-    after(:each) do
-      # generally transforms are global, but state should be 
-      # cleared when testing them here at the unit level
-      class StepMother; @@transforms = [] end
+    before do
+      @dsl = Object.new
+      @dsl.extend(RbSupport::RbDsl)
+
+      @step_mother = StepMother.new
+      @step_mother.load_natural_language('en')
+      @rb = @step_mother.load_programming_language('rb')
     end
 
     describe "without capture groups" do
       it "complains when registering with a with no transform block" do
         lambda do
-          StepMother.register_transform('^abc$')
-        end.should raise_error(Cucumber::ArityMismatchError)
+          @dsl.Transform('^abc$')
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
       end
       
       it "complains when registering with a zero-arg transform block" do
         lambda do
-          StepMother.register_transform('^abc$') {42}
-        end.should raise_error(Cucumber::ArityMismatchError)
+          @dsl.Transform('^abc$') {42}
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
       end
 
       it "complains when registering with a splat-arg transform block" do
         lambda do
-          StepMother.register_transform('^abc$') {|*splat| 42 }
-        end.should raise_error(Cucumber::ArityMismatchError)
+          @dsl.Transform('^abc$') {|*splat| 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
       end
 
       it "complains when transforming with an arity mismatch" do
         lambda do
-          StepMother.register_transform('^abc$') {|one, two| 42 }
-          StepMother.transform_arguments(['abc'])
+          @dsl.Transform('^abc$') {|one, two| 42 }
+          @rb.execute_transforms(['abc'])
         end.should raise_error(Cucumber::ArityMismatchError)
       end
 
       it "allows registering a regexp pattern that yields the step_arg matched" do
-        StepMother.register_transform(/^ab*c$/) {|arg| 42}
-        StepMother.transform_arguments(['ab']).should == ['ab']
-        StepMother.transform_arguments(['ac']).should == [42]
-        StepMother.transform_arguments(['abc']).should == [42]
-        StepMother.transform_arguments(['abbc']).should == [42]
+        @dsl.Transform(/^ab*c$/) {|arg| 42}
+        @rb.execute_transforms(['ab']).should == ['ab']
+        @rb.execute_transforms(['ac']).should == [42]
+        @rb.execute_transforms(['abc']).should == [42]
+        @rb.execute_transforms(['abbc']).should == [42]
       end
     end
 
     describe "with capture groups" do
       it "complains when registering with a with no transform block" do
         lambda do
-          StepMother.register_transform('^a(.)c$')
-        end.should raise_error(Cucumber::ArityMismatchError)
+          @dsl.Transform('^a(.)c$')
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
       end
       
       it "complains when registering with a zero-arg transform block" do
         lambda do
-          StepMother.register_transform('^a(.)c$') { 42 }
-        end.should raise_error(Cucumber::ArityMismatchError)
+          @dsl.Transform('^a(.)c$') { 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
       end
 
       it "complains when registering with a splat-arg transform block" do
         lambda do
-          StepMother.register_transform('^a(.)c$') {|*splat| 42 }
-        end.should raise_error(Cucumber::ArityMismatchError)
+          @dsl.Transform('^a(.)c$') {|*splat| 42 }
+        end.should raise_error(Cucumber::RbSupport::RbTransform::MissingProc)
       end
 
       it "complains when transforming with an arity mismatch" do
         lambda do
-          StepMother.register_transform('^a(.)c$') {|one, two| 42 }
-          StepMother.transform_arguments(['abc'])
+          @dsl.Transform('^a(.)c$') {|one, two| 42 }
+          @rb.execute_transforms(['abc'])
         end.should raise_error(Cucumber::ArityMismatchError)
       end
       
       it "allows registering a regexp pattern that yields capture groups" do
-        StepMother.register_transform(/^shape: (.+), color: (.+)$/) do |shape, color|
+        @dsl.Transform(/^shape: (.+), color: (.+)$/) do |shape, color|
           {shape.to_sym => color.to_sym}
         end
-        StepMother.transform_arguments(['shape: circle, color: blue']).should == [{:circle => :blue}]
-        StepMother.transform_arguments(['shape: square, color: red']).should == [{:square => :red}]      
-        StepMother.transform_arguments(['not shape: square, not color: red']).should == ['not shape: square, not color: red']
+        @rb.execute_transforms(['shape: circle, color: blue']).should == [{:circle => :blue}]
+        @rb.execute_transforms(['shape: square, color: red']).should == [{:square => :red}]
+        @rb.execute_transforms(['not shape: square, not color: red']).should == ['not shape: square, not color: red']
       end
     end
     
     it "allows registering a string pattern" do
-      StepMother.register_transform('^ab*c$') {|arg| 42}
-      StepMother.transform_arguments(['ab']).should == ['ab']
-      StepMother.transform_arguments(['ac']).should == [42]
-      StepMother.transform_arguments(['abc']).should == [42]
-      StepMother.transform_arguments(['abbc']).should == [42]
+      @dsl.Transform('^ab*c$') {|arg| 42}
+      @rb.execute_transforms(['ab']).should == ['ab']
+      @rb.execute_transforms(['ac']).should == [42]
+      @rb.execute_transforms(['abc']).should == [42]
+      @rb.execute_transforms(['abbc']).should == [42]
     end
 
     it "gives match priority to transforms defined last" do
-      StepMother.register_transform(/^transform_me$/) {|arg| :foo }
-      StepMother.register_transform(/^transform_me$/) {|arg| :bar }
-      StepMother.register_transform(/^transform_me$/) {|arg| :baz }
-      StepMother.transform_arguments(['transform_me']).should == [:baz]
+      @dsl.Transform(/^transform_me$/) {|arg| :foo }
+      @dsl.Transform(/^transform_me$/) {|arg| :bar }
+      @dsl.Transform(/^transform_me$/) {|arg| :baz }
+      @rb.execute_transforms(['transform_me']).should == [:baz]
     end
   end