cucumber 0.4.2 → 0.4.3

data/lib/cucumber/filter.rb

@@ -3,8 +3,7 @@ module Cucumber
   class Filter #:nodoc:
     def initialize(lines, options)
       @lines = lines
-
-      @tag_names = options[:tag_names] ? options[:tag_names].keys : []
+      @tag_names = options[:tag_names] ? options[:tag_names].map{|tags_with_limit| tags_with_limit.keys } : []
       @name_regexps = options[:name_regexps] || []
     end
 

data/lib/cucumber/formatter/ansicolor.rb

@@ -1,8 +1,8 @@
 require 'term/ansicolor'
+require 'cucumber/platform'
 
 if Cucumber::WINDOWS_MRI
   begin
-    gem 'win32console', '>= 1.2.0'
     require 'Win32/Console/ANSI'
   rescue LoadError
     STDERR.puts %{*** WARNING: You must "gem install win32console" (1.2.0 or higher) to get coloured output on MRI/Windows}
@@ -128,7 +128,22 @@ module Cucumber
       end
       
       define_grey
-      
+
+      def cukes(n)
+        ("(::) " * n).strip
+      end
+
+      def green_cukes(n)
+        blink(green(cukes(n)))
+      end
+
+      def red_cukes(n)
+        blink(red(cukes(n)))
+      end
+
+      def yellow_cukes(n)
+        blink(yellow(cukes(n)))
+      end
     end
   end
 end

data/lib/cucumber/formatter/console.rb

@@ -1,5 +1,6 @@
 require 'cucumber/formatter/ansicolor'
 require 'cucumber/formatter/duration'
+require 'cucumber/formatter/summary'
 
 module Cucumber
   module Formatter
@@ -8,6 +9,7 @@ module Cucumber
     module Console
       extend ANSIColor
       include Duration
+      include Summary
 
       FORMATS = Hash.new{|hash, format| hash[format] = method(format).to_proc}
 
@@ -73,11 +75,8 @@ module Cucumber
           @io.puts
         end
 
-        @io.print dump_count(step_mother.scenarios.length, "scenario")
-        print_status_counts{|status| step_mother.scenarios(status)}
-
-        @io.print dump_count(step_mother.steps.length, "step")
-        print_status_counts{|status| step_mother.steps(status)}
+        @io.puts scenario_summary(step_mother) {|status_count, status| format_string(status_count, status)}
+        @io.puts step_summary(step_mother) {|status_count, status| format_string(status_count, status)}
 
         @io.puts(format_duration(features.duration)) if features && features.duration
 
@@ -128,15 +127,17 @@ module Cucumber
       def print_tag_limit_warnings(options)
         if @tag_occurrences
           first_tag = true
-          options[:tag_names].each do |tag_name, limit|
-            unless Ast::Tags.exclude_tag?(tag_name)
-              tag_frequency = @tag_occurrences[tag_name].size
-              if limit && tag_frequency > limit
-                @io.puts if first_tag
-                first_tag = false
-                @io.puts format_string("#{tag_name} occurred #{tag_frequency} times, but the limit was set to #{limit}", :failed)
-                @tag_occurrences[tag_name].each {|location| @io.puts format_string("  #{location}", :failed)}
-                @io.flush
+          options[:tag_names].each do |tag_list|
+            tag_list.each do |tag_name, limit|
+              unless Ast::Tags.exclude_tag?(tag_name)
+                tag_frequency = @tag_occurrences[tag_name].size
+                if limit && tag_frequency > limit
+                  @io.puts if first_tag
+                  first_tag = false
+                  @io.puts format_string("#{tag_name} occurred #{tag_frequency} times, but the limit was set to #{limit}", :failed)
+                  @tag_occurrences[tag_name].each {|location| @io.puts format_string("  #{location}", :failed)}
+                  @io.flush
+                end
               end
             end
           end
@@ -145,37 +146,54 @@ module Cucumber
 
       def record_tag_occurrences(feature_element, options)
         @tag_occurrences ||= Hash.new{|k,v| k[v] = []}
-        options[:tag_names].each do |tag_name, limit|
-          if !Ast::Tags.exclude_tag?(tag_name) && feature_element.tag_count(tag_name) > 0
-            @tag_occurrences[tag_name] << feature_element.file_colon_line
+        options[:tag_names].each do |tag_list|
+          tag_list.each do |tag_name, limit|
+            if !Ast::Tags.exclude_tag?(tag_name) && feature_element.tag_count(tag_name) > 0
+              @tag_occurrences[tag_name] << feature_element.file_colon_line
+            end
           end
         end
       end
 
-      def announce(announcement)
-        @io.puts
-        @io.puts(format_string(announcement, :tag))
-        @io.flush
+      def embed(file, mime_type)
+        # no-op
       end
 
-    private
-
-      def print_status_counts
-        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
-          elements = yield status
-          elements.any? ? format_string("#{elements.length} #{status.to_s}", status) : nil
-        end.compact
-        if counts.any?
-          @io.puts(" (#{counts.join(', ')})")
+      #define @delayed_announcements = [] in your Formatter if you want to
+      #activate this feature
+      def announce(announcement)
+        if @delayed_announcements
+          @delayed_announcements << announcement
         else
           @io.puts
+          @io.puts(format_string(announcement, :tag))
+          @io.flush
         end
       end
 
-      def dump_count(count, what, state=nil)
-        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      def print_announcements()
+        @delayed_announcements.each {|ann| print_announcement(ann)}
+        empty_announcements
       end
 
+      def print_table_row_announcements
+        return if @delayed_announcements.empty?
+        @io.print(format_string(@delayed_announcements.join(', '), :tag).indent(2))
+        @io.flush
+        empty_announcements
+      end
+
+      def print_announcement(announcement)
+        @io.puts(format_string(announcement, :tag).indent(@indent))
+        @io.flush
+      end
+
+      def empty_announcements
+        @delayed_announcements = []
+      end
+
+    private
+
       def format_for(*keys)
         key = keys.join('_').to_sym
         fmt = FORMATS[key]

data/lib/cucumber/formatter/html.rb

@@ -1,5 +1,6 @@
 require 'cucumber/formatter/ordered_xml_markup'
 require 'cucumber/formatter/duration'
+require 'cucumber/formatter/summary'
 
 module Cucumber
   module Formatter
@@ -7,11 +8,13 @@ module Cucumber
     class Html
       include ERB::Util # for the #h method
       include Duration
+      include Summary
 
       def initialize(step_mother, io, options)
         @io = io
         @options = options
         @buffer = {}
+        @step_mother = step_mother
         @current_builder = create_builder(@io)
       end
       
@@ -38,6 +41,8 @@ module Cucumber
           builder.body do
             builder.div(:class => 'cucumber') do
               builder << buffer(:features)
+              builder.div(scenario_summary(@step_mother) {|status_count, _| status_count}, :class => 'summary')
+              builder.div(step_summary(@step_mother) {|status_count, _| status_count}, :class => 'summary')
               builder.div(format_duration(features.duration), :class => 'duration')
             end
           end
@@ -292,9 +297,24 @@ module Cucumber
       def announce(announcement)
         builder.pre(announcement, :class => 'announcement')
       end
-      
+
+      def embed(file, mime_type)
+        case(mime_type)
+        when /^image\/(png|gif|jpg)/
+          embed_image(file)
+        end
+      end
+
       private
       
+      def embed_image(file)
+        id = file.hash
+        builder.pre(:class => 'embed') do |pre|
+          pre << %{<a href="#" onclick="img=document.getElementById('#{id}'); img.style.display = (img.style.display == 'none' ? 'block' : 'none');">Screenshot</a>
+          <img id="#{id}" style="display: none" src="#{file}" />}
+        end
+      end
+
       def build_step(keyword, step_match, status)
         step_name = step_match.format_args(lambda{|param| %{<span class="param">#{param}</span>}})
         builder.div do |div|

data/lib/cucumber/formatter/junit.rb

@@ -4,6 +4,12 @@ module Cucumber
   module Formatter
     # The formatter used for <tt>--format junit</tt>
     class Junit
+      class UnNamedFeatureError < StandardError
+        def initialize(feature_file)
+          super("The feature in '#{feature_file}' does not have a name. The JUnit XML format requires a name for the testsuite element.")
+        end
+      end
+      
       def initialize(step_mother, io, options)
         raise "You *must* specify --out DIR for the junit formatter" unless String === io && File.directory?(io)
         @reportdir = io
@@ -11,6 +17,7 @@ module Cucumber
       end
 
       def before_feature(feature)
+        @current_feature = feature
         @failures = @errors = @tests = 0
         @builder = OrderedXmlMarkup.new( :indent => 2 )
         @time = 0
@@ -40,6 +47,7 @@ module Cucumber
       end
 
       def feature_name(name)
+        raise UnNamedFeatureError.new(@current_feature.file) if name.empty?
         lines = name.split(/\r?\n/)
         @feature_name = lines[0].sub(/Feature\:/, '').strip
       end

data/lib/cucumber/formatter/pretty.rb

@@ -21,6 +21,7 @@ module Cucumber
         @exceptions = []
         @indent = 0
         @prefixes = options[:prefixes] || {}
+        @delayed_announcements = []
       end
 
       def after_features(features)
@@ -150,6 +151,7 @@ module Cucumber
         source_indent = nil unless @options[:source]
         name_to_report = format_step(keyword, step_match, status, source_indent)
         @io.puts(name_to_report.indent(@scenario_indent + 2))
+        print_announcements
       end
 
       def py_string(string)
@@ -183,6 +185,7 @@ module Cucumber
 
       def after_table_row(table_row)
         return unless @table
+        print_table_row_announcements
         @io.puts
         if table_row.exception && !@exceptions.include?(table_row.exception)
           print_exception(table_row.exception, :failed, @indent)

data/lib/cucumber/formatter/summary.rb

@@ -0,0 +1,35 @@
+module Cucumber
+  module Formatter
+    module Summary
+
+      def scenario_summary(step_mother, &block)
+        scenarios_proc = lambda{|status| step_mother.scenarios(status)}
+        dump_count(step_mother.scenarios.length, "scenario") + dump_status_counts(scenarios_proc, &block)
+      end
+
+      def step_summary(step_mother, &block)
+        steps_proc = lambda{|status| step_mother.steps(status)}
+        dump_count(step_mother.steps.length, "step") + dump_status_counts(steps_proc, &block)
+      end
+
+      private
+
+      def dump_status_counts(find_elements_proc)
+        counts = [:failed, :skipped, :undefined, :pending, :passed].map do |status|
+          elements = find_elements_proc.call(status)
+          elements.any? ? yield("#{elements.length} #{status.to_s}", status) : nil
+        end.compact
+        if counts.any?
+          " (#{counts.join(', ')})"
+        else
+          ""
+        end
+      end
+
+      def dump_count(count, what, state=nil)
+        [count, state, "#{what}#{count == 1 ? '' : 's'}"].compact.join(" ")
+      end
+
+    end
+  end
+end

data/lib/cucumber/formatter/usage.rb

@@ -19,14 +19,14 @@ module Cucumber
 
       def before_step(step)
         @step = step
+        @start_time = Time.now
       end
 
-      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
-        @step_duration = Time.now
+      def before_step_result(*args)
+        @duration = Time.now - @start_time
       end
 
       def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
-        duration = Time.now - @step_duration
         if step_match.name.nil? # nil if it's from a scenario outline
           stepdef_key = StepDefKey.new(step_match.step_definition.regexp_source, step_match.step_definition.file_colon_line)
 
@@ -35,7 +35,7 @@ module Cucumber
             :step_match => step_match, 
             :status => status, 
             :file_colon_line => @step.file_colon_line,
-            :duration => duration
+            :duration => @duration
           }
         end
         super

data/lib/cucumber/rails/active_record.rb

@@ -13,24 +13,32 @@ if defined?(ActiveRecord::Base)
 
   Before do
     if Cucumber::Rails::World.use_transactional_fixtures
-      @__cucumber_ar_connection = ActiveRecord::Base.connection
-      if @__cucumber_ar_connection.respond_to?(:increment_open_transactions)
-        @__cucumber_ar_connection.increment_open_transactions
+      @__cucumber_ar_connections = if ActiveRecord::Base.respond_to?(:connection_handler)
+        ActiveRecord::Base.connection_handler.connection_pools.values.map {|pool| pool.connection}
       else
-        ActiveRecord::Base.__send__(:increment_open_transactions)
+        [ActiveRecord::Base.connection] # Rails <= 2.1.2
+      end
+      @__cucumber_ar_connections.each do |__cucumber_ar_connection|
+        if __cucumber_ar_connection.respond_to?(:increment_open_transactions)
+          __cucumber_ar_connection.increment_open_transactions
+        else
+          ActiveRecord::Base.__send__(:increment_open_transactions)
+        end
+        __cucumber_ar_connection.begin_db_transaction
       end
-      @__cucumber_ar_connection.begin_db_transaction
     end
     ActionMailer::Base.deliveries = [] if defined?(ActionMailer::Base)
   end
 
   After do
     if Cucumber::Rails::World.use_transactional_fixtures
-      @__cucumber_ar_connection.rollback_db_transaction
-      if @__cucumber_ar_connection.respond_to?(:decrement_open_transactions)
-        @__cucumber_ar_connection.decrement_open_transactions
-      else
-        ActiveRecord::Base.__send__(:decrement_open_transactions)
+      @__cucumber_ar_connections.each do |__cucumber_ar_connection|
+        __cucumber_ar_connection.rollback_db_transaction
+        if __cucumber_ar_connection.respond_to?(:decrement_open_transactions)
+          __cucumber_ar_connection.decrement_open_transactions
+        else
+          ActiveRecord::Base.__send__(:decrement_open_transactions)
+        end
       end
     end
   end

data/lib/cucumber/rb_support/rb_language.rb

@@ -37,6 +37,9 @@ module Cucumber
         RbDsl.rb_language = self
       end
 
+      # Tell the language about other i18n translations so that
+      # they can alias Given, When Then etc. Only useful if the language
+      # has a mechanism for this - typically a dynamic language.
       def alias_adverbs(adverbs)
         adverbs.each do |adverb|
           RbDsl.alias_adverb(adverb)
@@ -44,9 +47,11 @@ module Cucumber
         end
       end
 
-      def step_definitions_for(code_file)
+      # Gets called for each file under features (or whatever is overridden
+      # with --require).
+      def step_definitions_for(rb_file)
         begin
-          load_code_file(code_file)
+          require rb_file # This will cause self.add_step_definition and self.add_hook to be called from RbDsl
           step_definitions
         rescue LoadError => e
           e.message << "\nFailed to load #{code_file}"

data/lib/cucumber/rb_support/rb_world.rb

@@ -64,6 +64,10 @@ module Cucumber
         @__cucumber_step_mother.announce(announcement)
       end
 
+      def embed(file, mime_type)
+        @__cucumber_step_mother.embed(file, mime_type)
+      end
+
       # Mark the matched step as pending.
       def pending(message = "TODO")
         if block_given?

data/lib/cucumber/step_match.rb

@@ -6,6 +6,7 @@ module Cucumber
     # in which case +name_to_report+ is used instead.
     # 
     def initialize(step_definition, name_to_match, name_to_report, step_arguments)
+      raise "name_to_match can't be nil" if name_to_match.nil?
       @step_definition, @name_to_match, @name_to_report, @step_arguments = step_definition, name_to_match, name_to_report, step_arguments
     end
 
@@ -67,8 +68,8 @@ module Cucumber
           format % step_argument.val
         end
 
-        s[step_argument.pos + offset, step_argument.val.jlength] = replacement
-        offset += replacement.length - step_argument.val.jlength
+        s[step_argument.pos + offset, step_argument.val.length] = replacement
+        offset += replacement.jlength - step_argument.val.jlength
       end
       s
     end

data/lib/cucumber/step_mother.rb

@@ -130,6 +130,10 @@ module Cucumber
       @visitor.announce(msg)
     end
 
+    def embed(file, mime_type)
+      @visitor.embed(file, mime_type)
+    end
+
     def scenarios(status = nil) #:nodoc:
       @scenarios ||= []
       if(status)
@@ -238,7 +242,8 @@ module Cucumber
         return nil if @unsupported_programming_languages.index(ext)
         begin
           load_programming_language(ext)
-        rescue LoadError
+        rescue LoadError => e
+          log.debug("Failed to load '#{ext}' programming language for file #{step_def_file}: #{e.message}\n")
           @unsupported_programming_languages << ext
           nil
         end