cucumber 0.3.101 → 0.3.102

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_group.rb

@@ -0,0 +1,11 @@
+module Cucumber
+  module RbSupport
+    class RbGroup
+      attr_reader :val, :start
+      
+      def initialize(val, start)
+        @val, @start = val, start
+      end
+    end
+  end
+end

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

@@ -1,6 +1,7 @@
 require 'cucumber/step_match'
 require 'cucumber/core_ext/string'
 require 'cucumber/core_ext/proc'
+require 'cucumber/rb_support/rb_group'
 
 module Cucumber
   module RbSupport
@@ -23,24 +24,38 @@ module Cucumber
         end
       end
 
-      attr_reader :proc
+      attr_reader :proc, :regexp
 
-      def initialize(rb_language, pattern, proc)
+      def initialize(rb_language, regexp, proc)
         raise MissingProc if proc.nil?
-        if String === pattern
-          p = pattern.gsub(/\$\w+/, '(.*)') # Replace $var with (.*)
-          pattern = Regexp.new("^#{p}$") 
+        if String === regexp
+          p = regexp.gsub(/\$\w+/, '(.*)') # Replace $var with (.*)
+          regexp = Regexp.new("^#{p}$") 
         end
-        @rb_language, @regexp, @proc = rb_language, pattern, proc
+        @rb_language, @regexp, @proc = rb_language, regexp, proc
       end
 
-      def regexp
-        @regexp
+      def ==(step_definition)
+        self.regexp == step_definition.regexp
+      end
+
+      def groups(step_name)
+        match = regexp.match(step_name)
+        if match
+          n = 0
+          match.captures.map do |val|
+            n += 1
+            RbGroup.new(val, match.offset(n)[0])
+          end
+        else
+          nil
+        end
       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

@@ -1,9 +1,13 @@
 module Cucumber
   class StepMatch #:nodoc:
-    attr_reader :step_definition, :args
+    attr_reader :step_definition
 
-    def initialize(step_definition, step_name, formatted_step_name, args)
-      @step_definition, @step_name, @formatted_step_name, @args = step_definition, step_name, formatted_step_name, args
+    def initialize(step_definition, step_name, formatted_step_name, groups)
+      @step_definition, @step_name, @formatted_step_name, @groups = step_definition, step_name, formatted_step_name, groups
+    end
+
+    def args
+      @groups.map{|g| g.val}
     end
 
     def name
@@ -11,13 +15,28 @@ module Cucumber
     end
 
     def invoke(multiline_arg)
-      all_args = @args.dup
+      all_args = args
       all_args << multiline_arg if multiline_arg
       @step_definition.invoke(all_args)
     end
 
+    # Formats the matched arguments of the associated Step. This method
+    # is usually called from visitors, which render output.
+    #
+    # The +format+ can either be a String or a Proc.
+    #
+    # If it is a String it should be a format string according to
+    # <tt>Kernel#sprinf</tt>, for example:
+    #
+    #   '<span class="param">%s</span></tt>'
+    #
+    # If it is a Proc, it should take one argument and return the formatted
+    # argument, for example:
+    #
+    #   lambda { |param| "[#{param}]" }
+    #
     def format_args(format = lambda{|a| a})
-      @formatted_step_name || @step_definition.format_args(@step_name, format)
+      @formatted_step_name || @step_name.gzub(@groups, format)
     end
     
     def file_colon_line
@@ -58,4 +77,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,
@@ -272,7 +249,7 @@ module Cucumber
     # 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)
+        raise Redundant.new(already, step_definition) if already == step_definition
       end
       step_definitions << step_definition
       step_definition

data/lib/cucumber/version.rb

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

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