aslakhellesoy-cucumber 0.3.101.2 → 0.3.102

data/History.txt

@@ -1,8 +1,10 @@
-== (In Git)
+== 2009-09-22
 
 This release has some changes in the Rails support, so make sure you run "script/generate cucumber" after you upgrade.
+Other noteworthy new features are improved Hook, tags and Transform support, and as always - several smaler bug fixes.
 
 === New Features
+* Added new internal API for Regexp and groups, allowing other programming languages to leverage native regexps. (Aslak Hellesøy)
 * New @allow_rescue tag for Rails scenarios. Causes exceptions raised in actions to be caught by rails and not bubble up to Cucumber (Aslak Hellesøy)
 * Negative tags can now be used in hooks, just like the command line's --tags option: Before('~@yarr') - will run for all scenarios that *don't* have the @yarr tag. (Aslak Hellesøy)
 * Transform has current "World" scope (Larry Diehl)
@@ -10,6 +12,9 @@ This release has some changes in the Rails support, so make sure you run "script
 * Execute "After" hooks in reverse order of declaration for better behavior with dependent blocks and to mimic the behavior of at_exit (David Waite)
 
 === Bugfixes
+* features/support/env.rb runs commands twice (bugfix cuts total time by almost 50% w00t) (#452 Jim Meyer)
+* Problems adding custom formatters to features/support. (features/support is added to $LOAD_PATH) (#449 Aslak Hellesøy)
+* Some options set in cucumber.yml profiles are ignored (#446 Leonard CHIN)
 * Missing step_definition snippets not properly displayed (#433 Aslak Hellesøy)
 * rspec-rails, :lib => false (#447 David Chelimsky)
 * Cucumber with Spork breaks on OS X Snow Leopard (#431 David Chelimsky)

data/Manifest.txt

@@ -385,6 +385,7 @@ lib/cucumber/rails/test_unit.rb
 lib/cucumber/rails/world.rb
 lib/cucumber/rake/task.rb
 lib/cucumber/rb_support/rb_dsl.rb
+lib/cucumber/rb_support/rb_group.rb
 lib/cucumber/rb_support/rb_hook.rb
 lib/cucumber/rb_support/rb_language.rb
 lib/cucumber/rb_support/rb_step_definition.rb

data/features/custom_formatter.feature

@@ -8,4 +8,39 @@ Feature: Custom Formatter
       | 1           | 1                                    | 1     | 1     | 1    | 2            | 1           | 2             | 1           | 2      | 1    |
 
       """
-    
+  
+    Scenario: my own formatter
+      Given a standard Cucumber project directory structure
+      And a file named "features/f.feature" with:
+        """
+        Feature: i'll use my own
+          Scenario: just print me
+            Given this step works
+        """
+      And a file named "features/step_definitions/steps.rb" with:
+        """
+        Given /^this step works$/ do
+        end
+        """
+      And a file named "features/support/ze/formator.rb" with:
+        """
+        module Ze
+          class Formator < Cucumber::Ast::Visitor
+            def initialize(step_mother, io, options)
+              super(step_mother)
+              @io = io
+            end
+
+            def visit_scenario_name(keyword, name, file_colon_line, source_indent)
+              @io.puts "$ #{name.upcase}"
+            end
+          end
+        end
+        """
+      When I run cucumber features/f.feature --format Ze::Formator
+      Then STDERR should be empty
+      Then it should pass with
+        """
+        $ JUST PRINT ME
+
+        """

data/features/support/env.rb

@@ -61,6 +61,7 @@ class CucumberWorld
   def create_file(file_name, file_content)
     file_content.gsub!("CUCUMBER_LIB", "'#{cucumber_lib_dir}'") # Some files, such as Rakefiles need to use the lib dir
     in_current_dir do
+      FileUtils.mkdir_p(File.dirname(file_name)) unless File.directory?(File.dirname(file_name))
       File.open(file_name, 'w') { |f| f << file_content }
     end
   end
@@ -83,7 +84,6 @@ class CucumberWorld
     stderr_file = Tempfile.new('cucumber')
     stderr_file.close
     in_current_dir do
-      @last_stdout = `#{command} 2> #{stderr_file.path}`
       mode = Cucumber::RUBY_1_9 ? {:external_encoding=>"UTF-8"} : 'r'
       IO.popen("#{command} 2> #{stderr_file.path}", mode) do |io|
         @last_stdout = io.read

data/lib/cucumber/cli/main.rb

@@ -47,6 +47,7 @@ module Cucumber
         step_mother.after_configuration(configuration)
         features = step_mother.load_plain_text_features(configuration.feature_files)
         step_mother.load_code_files(configuration.step_defs_to_load)
+
         enable_diffing
 
         visitor = configuration.build_formatter_broadcaster(step_mother)

data/lib/cucumber/cli/options.rb

@@ -319,6 +319,8 @@ module Cucumber
       def reverse_merge(other_options)
         @options = other_options.options.merge(@options)
         @options[:require] += other_options[:require]
+        @options[:excludes] += other_options[:excludes]
+        @options[:name_regexps] += other_options[:name_regexps]
         @options[:tag_names].merge! other_options[:tag_names]
         @options[:env_vars] = other_options[:env_vars].merge(@options[:env_vars])
         if @options[:paths].empty?

data/lib/cucumber/constantize.rb

@@ -1,7 +1,9 @@
 module Cucumber
   module Constantize #:nodoc:
     def constantize(camel_cased_word)
+      try = 0
       begin
+        try += 1
         names = camel_cased_word.split('::')
         names.shift if names.empty? || names.first.empty?
 
@@ -10,9 +12,13 @@ module Cucumber
           constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
         end
         constant
-      rescue NameError
+      rescue NameError => e
         require underscore(camel_cased_word)
-        retry
+        if try < 2
+          retry
+        else
+          raise e
+        end
       end
     end
 

data/lib/cucumber/core_ext/string.rb

@@ -7,34 +7,24 @@ class String #:nodoc:
     end
   end
   
-  # re.source.gsub(/\([^)]*\)/, '$var')
-  # Cumulative #sub
-  def subs(re, *args)
-    args.inject(self) do |s,arg|
-      s.sub(re, arg)
-    end
-  end
-
-  # TODO: Use subs instead...
-  def gzub(regexp, format=nil, &proc)
-    md = match(regexp)
-    raise "#{self.inspect} doesn't match #{regexp.inspect}" if md.nil?
-    
+  # TODO: Move to StepMatch
+  # +groups+ is an array of 2-element arrays, where
+  # the 1st element is the value of a regexp match group,
+  # and the 2nd element is its start index.
+  def gzub(groups, format=nil, &proc)
     s = dup
-    pos = 0
-    md.captures.each_with_index do |m, n|
+    offset = 0
+    groups.each do |group|
       replacement = if block_given?
-        proc.call(m)
+        proc.call(group.val)
       elsif Proc === format
-        format.call(m)
+        format.call(group.val)
       else
-        format % m
+        format % group.val
       end
       
-      if md.offset(n+1)[0]
-        s[md.offset(n+1)[0] + pos, m.length] = replacement
-        pos += replacement.length - m.length
-      end
+      s[group.start + offset, group.val.length] = replacement
+      offset += replacement.length - group.val.length
     end
     s
   end

data/lib/cucumber/language_support/step_definition_methods.rb

@@ -4,36 +4,13 @@ module Cucumber
   module LanguageSupport
     module StepDefinitionMethods
       def step_match(name_to_match, name_to_report)
-        if(match = regexp.match(name_to_match))
-          StepMatch.new(self, name_to_match, name_to_report, match.captures)
+        if(groups = groups(name_to_match))
+          StepMatch.new(self, name_to_match, name_to_report, groups)
         else
           nil
         end
       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(step_name, format)
-        step_name.gzub(regexp, format)
-      end
-
-      def same_regexp?(regexp)
-        self.regexp == regexp
-      end
-
       def backtrace_line
         "#{file_colon_line}:in `#{regexp.inspect}'"
       end

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_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
@@ -25,13 +26,30 @@ module Cucumber
 
       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, regexp, proc
+      end
+
+      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
-        @rb_language, @regexp, @proc = rb_language, pattern, proc
       end
 
       def invoke(args)

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

data/lib/cucumber/step_mother.rb

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

data/spec/cucumber/core_ext/string_spec.rb

@@ -1,19 +1,24 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
-require File.dirname(__FILE__) + '/../../../lib/cucumber/core_ext/string'
+require 'cucumber/core_ext/string'
+require 'cucumber/rb_support/rb_group'
 
 describe String, "#gzub" do
+  def groups(a)
+    a.map{|c| Cucumber::RbSupport::RbGroup.new(c[0], c[1])}
+  end
+  
   it "should format groups with format string" do
-    "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/, "<span>%s</span>").should ==
+    "I ate 1 egg this morning".gzub(groups([['ate', 2], ['1', 6], ['egg', 8],  ['morning', 17]]), "<span>%s</span>").should ==
     "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
   end
 
   it "should format groups with format string when there are dupes" do
-    "I bob 1 bo this bobs".gzub(/I (\w+) (\d+) (\w+) this (\w+)/, "<span>%s</span>").should ==
+    "I bob 1 bo this bobs".gzub(groups([['bob', 2], ['1', 6], ['bo', 8],  ['bobs', 16]]), "<span>%s</span>").should ==
     "I <span>bob</span> <span>1</span> <span>bo</span> this <span>bobs</span>"
   end
 
   it "should format groups with block" do
-    f = "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/) do |m|
+    f = "I ate 1 egg this morning".gzub(groups([['ate', 2], ['1', 6], ['egg', 8],  ['morning', 17]])) do |m|
       "<span>#{m}</span>"
     end
     f.should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
@@ -23,21 +28,14 @@ describe String, "#gzub" do
     proc = lambda do |m|
       "<span>#{m}</span>"
     end
-    f = "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/, proc)
+    f = "I ate 1 egg this morning".gzub(groups([['ate', 2], ['1', 6], ['egg', 8],  ['morning', 17]]), proc)
     f.should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
   end
   
   it "should format groups with block with not all placeholders having a value" do
-    f = "another member named Bob joins the group".gzub(/(a|another) (user|member) named ([^ ]+)( who is not logged in)?/) do |m|
+    f = "another member named Bob joins the group".gzub(groups([['another', 0], ['member', 8], ['Bob', 21]])) do |m|
       "<span>#{m}</span>"
     end
     f.should == "<span>another</span> <span>member</span> named <span>Bob</span> joins the group"
   end
-
-  it "should format match groups in a textile table row" do
-    f = "I ate 1 egg this morning".gzub(/I (\w+) (\d+) (\w+) this (\w+)/) do |m|
-      "<span>#{m}</span>"
-    end
-    f.should == "I <span>ate</span> <span>1</span> <span>egg</span> this <span>morning</span>"
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: aslakhellesoy-cucumber
 version: !ruby/object:Gem::Version 
-  version: 0.3.101.2
+  version: 0.3.102
 platform: ruby
 authors: 
 - "Aslak Helles\xC3\xB8y"
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-21 00:00:00 -07:00
+date: 2009-09-22 00:00:00 -07:00
 default_executable: cucumber
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -463,6 +463,7 @@ files:
 - lib/cucumber/rails/world.rb
 - lib/cucumber/rake/task.rb
 - lib/cucumber/rb_support/rb_dsl.rb
+- lib/cucumber/rb_support/rb_group.rb
 - lib/cucumber/rb_support/rb_hook.rb
 - lib/cucumber/rb_support/rb_language.rb
 - lib/cucumber/rb_support/rb_step_definition.rb