actionpack 1.7.0 → 1.8.0

data/lib/action_controller/benchmarking.rb

@@ -19,7 +19,11 @@ module ActionController #:nodoc:
       if logger.nil?
         render_without_benchmark(template_name, status)
       else
+        db_runtime = ActiveRecord::Base.connection.reset_runtime
         @rendering_runtime = Benchmark::measure{ render_without_benchmark(template_name, status) }.real
+        @db_rt_before_render = db_runtime
+        @db_rt_after_render = ActiveRecord::Base.connection.reset_runtime
+        @rendering_runtime -= @db_rt_after_render
       end
     end    
 
@@ -28,7 +32,7 @@ module ActionController #:nodoc:
         perform_action_without_benchmark
       else
         runtime = [Benchmark::measure{ perform_action_without_benchmark }.real, 0.0001].max
-        log_message  = "Completed in #{sprintf("%4f", runtime)} (#{(1 / runtime).floor} reqs/sec)"
+        log_message  = "Completed in #{sprintf("%.5f", runtime)} (#{(1 / runtime).floor} reqs/sec)"
         log_message << rendering_runtime(runtime) if @rendering_runtime
         log_message << active_record_runtime(runtime) if Object.const_defined?("ActiveRecord") && ActiveRecord::Base.connected?
         logger.info(log_message)
@@ -37,13 +41,15 @@ module ActionController #:nodoc:
     
     private
       def rendering_runtime(runtime)
-        " | Rendering: #{sprintf("%f", @rendering_runtime)} (#{sprintf("%d", (@rendering_runtime / runtime) * 100)}%)"
+        " | Rendering: #{sprintf("%.5f", @rendering_runtime)} (#{sprintf("%d", (@rendering_runtime * 100) / runtime)}%)"
       end
 
       def active_record_runtime(runtime)
         db_runtime    = ActiveRecord::Base.connection.reset_runtime
-        db_percentage = (db_runtime / runtime) * 100
-        " | DB: #{sprintf("%f", db_runtime)} (#{sprintf("%d", db_percentage)}%)"
+        db_runtime    += @db_rt_before_render if @db_rt_before_render
+        db_runtime    += @db_rt_after_render if @db_rt_after_render
+        db_percentage = (db_runtime * 100) / runtime
+        " | DB: #{sprintf("%.5f", db_runtime)} (#{sprintf("%d", db_percentage)}%)"
       end
   end
 end

data/lib/action_controller/caching.rb

@@ -99,7 +99,7 @@ module ActionController #:nodoc:
         private
           def page_cache_file(path)
             name = ((path.empty? || path == "/") ? "/index" : path)
-            name << @@page_cache_extension unless (name.split('/').last || name).include? '.'
+            name << page_cache_extension unless (name.split('/').last || name).include? '.'
             return name
           end
         
@@ -114,10 +114,10 @@ module ActionController #:nodoc:
         return unless perform_caching
         if options[:action].is_a?(Array)
           options[:action].dup.each do |action|
-            self.class.expire_page(url_for(options.merge({ :only_path => true, :action => action })))
+            self.class.expire_page(url_for(options.merge({ :only_path => true, :skip_relative_url_root => true, :action => action })))
           end
         else
-          self.class.expire_page(url_for(options.merge({ :only_path => true })))
+          self.class.expire_page(url_for(options.merge({ :only_path => true, :skip_relative_url_root => true })))
         end
       end
 
@@ -126,7 +126,7 @@ module ActionController #:nodoc:
       #   cache_page "I'm the cached content", :controller => "lists", :action => "show"
       def cache_page(content = nil, options = {})
         return unless perform_caching && caching_allowed
-        self.class.cache_page(content || @response.body, url_for(options.merge({ :only_path => true })))
+        self.class.cache_page(content || @response.body, url_for(options.merge({ :only_path => true, :skip_relative_url_root => true })))
       end
 
       private
@@ -256,6 +256,15 @@ module ActionController #:nodoc:
         end
       end
 
+      def cache_base_url
+        @@cache_base_url ||= url_for(:controller => '')
+      end
+
+      def fragment_cache_key(name)
+        key = name.is_a?(Hash) ? url_for(name) : cache_base_url + name
+        key.split("://").last
+      end
+
       # Called by CacheHelper#cache
       def cache_erb_fragment(block, name = {}, options = {})
         unless perform_caching then block.call; return end
@@ -272,16 +281,16 @@ module ActionController #:nodoc:
       end
       
       def write_fragment(name, content, options = {})
-        name = url_for(name).split("://").last if name.is_a?(Hash)
-        fragment_cache_store.write(name, content, options)
-        logger.info "Cached fragment: #{name}" unless logger.nil?
+        key = fragment_cache_key(name)
+        fragment_cache_store.write(key, content, options)
+        logger.info "Cached fragment: #{key}" unless logger.nil?
         content
       end
       
       def read_fragment(name, options = {})
-        name = url_for(name).split("://").last if name.is_a?(Hash)
-        if cache = fragment_cache_store.read(name, options)
-          logger.info "Fragment hit: #{name}" unless logger.nil?
+        key = fragment_cache_key(name)
+        if cache = fragment_cache_store.read(key, options)
+          logger.info "Fragment hit: #{key}" unless logger.nil?
           cache
         else
           false
@@ -289,14 +298,15 @@ module ActionController #:nodoc:
       end
       
       def expire_fragment(name, options = {})
-        name = url_for(name).split("://").last if name.is_a?(Hash)
-        fragment_cache_store.delete(name, options)
-        logger.info "Expired fragment: #{name}" unless logger.nil?
+        key = fragment_cache_key(name)
+        fragment_cache_store.delete(key, options)
+        logger.info "Expired fragment: #{key}" unless logger.nil?
       end
 
-      def expire_matched_fragments(re=Regexp.new('/*/'), options = {})
-        fragment_cache_store.delete_matched(re, { :root_path => url_for.split('://').last.split('/').first })
-        logger.info "Expired all fragments matching: #{re} " unless logger.nil?
+      def expire_matched_fragments(re=Regexp.new('/.*/'), options = {})
+        rp = cache_base_url.split("://").last
+        fragment_cache_store.delete_matched(re, { :root_path => rp })
+        logger.info "Expired all fragments matching: #{rp}#{re.source}" unless logger.nil?
       end
 
       class MemoryStore #:nodoc:
@@ -317,7 +327,8 @@ module ActionController #:nodoc:
         end
 
         def delete_matched(re, options) #:nodoc:
-          @mutex.synchronize { @data.delete_if {|k,v| k.index(options[:root_path]) == 0 and k =~ re} }
+          re = Regexp.new("#{Regexp.escape(options[:root_path])}#{re.source}")
+          @mutex.synchronize { @data.delete_if { |k,v| k =~ re } }
         end
       end
 

data/lib/action_controller/cgi_ext/raw_post_data_fix.rb

@@ -11,7 +11,7 @@ class CGI #:nodoc:
         @params = read_multipart(boundary, Integer(env_table['CONTENT_LENGTH']))
       else
         @multipart = false
-        @params = CGI::parse(read_query_params)
+        @params = CGI::parse(read_query_params || "")
       end
       
       @cookies = CGI::Cookie::parse((env_table['HTTP_COOKIE'] || env_table['COOKIE']))
@@ -28,16 +28,12 @@ class CGI #:nodoc:
 
       def read_query_params
         case env_table['REQUEST_METHOD']
-          when 'GET', 'HEAD'
-            if defined? MOD_RUBY              
-              Apache::request.args || ''
-            else
-              env_table['QUERY_STRING'] || ''
-            end
-          when 'POST'
+          when 'GET', 'HEAD', 'DELETE', 'OPTIONS'
+            (defined?(MOD_RUBY) ? Apache::request.args : env_table['QUERY_STRING']) || ''
+          when 'POST', 'PUT'
             stdinput.binmode if stdinput.respond_to?(:binmode)
             content = stdinput.read(Integer(env_table['CONTENT_LENGTH'])) || ''
-            env_table['RAW_POST_DATA'] = content.split("&_").first.freeze # &_ is a fix for Safari Ajax postings that always append \000
+            env_table['RAW_POST_DATA'] = content.split("&_").first.to_s.freeze # &_ is a fix for Safari Ajax postings that always append \000
           else
             read_from_cmdline
           end

data/lib/action_controller/cgi_process.rb

@@ -48,7 +48,11 @@ module ActionController #:nodoc:
 
     def query_string
       return @cgi.query_string unless @cgi.query_string.nil? || @cgi.query_string.empty?
-      parts = env['REQUEST_URI'].split('?')
+      unless env['REQUEST_URI'].nil?
+        parts = env['REQUEST_URI'].split('?')
+      else
+        return env['QUERY_STRING'] || ''
+      end      
       parts.shift
       return parts.join('?')
     end

data/lib/action_controller/cookies.rb

@@ -54,9 +54,10 @@ module ActionController #:nodoc:
       set_cookie(options)
     end
     
-    # Removes the cookie on the client machine by setting the value to an empty string.
+    # Removes the cookie on the client machine by setting the value to an empty string
+    # and setting its expiration date into the past
     def delete(name)
-      set_cookie("name" => name.to_s, "value" => "")
+      set_cookie("name" => name.to_s, "value" => "", "expires" => Time.at(0))
     end
 
     private

data/lib/action_controller/deprecated_assertions.rb

@@ -0,0 +1,204 @@
+require 'test/unit'
+require 'test/unit/assertions'
+require 'rexml/document'
+
+module Test #:nodoc:
+  module Unit #:nodoc:
+    module Assertions
+      def assert_success(message=nil) #:nodoc:
+        assert_response(:success, message)
+      end
+
+      def assert_redirect(message=nil) #:nodoc:
+        assert_response(:redirect, message)
+      end
+
+      def assert_rendered_file(expected=nil, message=nil) #:nodoc:
+        assert_template(expected, message)
+      end
+
+      # ensure that the session has an object with the specified name
+      def assert_session_has(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is not in the session <?>", key, @response.session)
+        assert_block(msg) { @response.has_session_object?(key) }
+      end
+
+      # ensure that the session has no object with the specified name
+      def assert_session_has_no(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is in the session <?>", key, @response.session)
+        assert_block(msg) { !@response.has_session_object?(key) }
+      end
+
+      def assert_session_equal(expected = nil, key = nil, message = nil) #:nodoc:
+        msg = build_message(message, "<?> expected in session['?'] but was <?>", expected, key, @response.session[key])
+        assert_block(msg) { expected == @response.session[key] }
+      end
+
+      # -- cookie assertions ---------------------------------------------------
+
+      def assert_no_cookie(key = nil, message = nil) #:nodoc:
+        actual = @response.cookies[key]
+        msg = build_message(message, "<?> not expected in cookies['?']", actual, key)
+        assert_block(msg) { actual.nil? or actual.empty? }
+      end
+    
+      def assert_cookie_equal(expected = nil, key = nil, message = nil) #:nodoc:
+        actual = @response.cookies[key]
+        actual = actual.first if actual
+        msg = build_message(message, "<?> expected in cookies['?'] but was <?>", expected, key, actual)
+        assert_block(msg) { expected == actual }
+      end
+    
+      # -- flash assertions ---------------------------------------------------
+
+      # ensure that the flash has an object with the specified name
+      def assert_flash_has(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is not in the flash <?>", key, @response.flash)
+        assert_block(msg) { @response.has_flash_object?(key) }
+      end
+
+      # ensure that the flash has no object with the specified name
+      def assert_flash_has_no(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is in the flash <?>", key, @response.flash)
+        assert_block(msg) { !@response.has_flash_object?(key) }
+      end
+
+      # ensure the flash exists
+      def assert_flash_exists(message=nil) #:nodoc:
+        msg = build_message(message, "the flash does not exist <?>", @response.session['flash'] )
+        assert_block(msg) { @response.has_flash? }
+      end
+
+      # ensure the flash does not exist
+      def assert_flash_not_exists(message=nil) #:nodoc:
+        msg = build_message(message, "the flash exists <?>", @response.flash)
+        assert_block(msg) { !@response.has_flash? }
+      end
+    
+      # ensure the flash is empty but existent
+      def assert_flash_empty(message=nil) #:nodoc:
+        msg = build_message(message, "the flash is not empty <?>", @response.flash)
+        assert_block(msg) { !@response.has_flash_with_contents? }
+      end
+
+      # ensure the flash is not empty
+      def assert_flash_not_empty(message=nil) #:nodoc:
+        msg = build_message(message, "the flash is empty")
+        assert_block(msg) { @response.has_flash_with_contents? }
+      end
+    
+      def assert_flash_equal(expected = nil, key = nil, message = nil) #:nodoc:
+        msg = build_message(message, "<?> expected in flash['?'] but was <?>", expected, key, @response.flash[key])
+        assert_block(msg) { expected == @response.flash[key] }
+      end
+    
+
+      # ensure our redirection url is an exact match
+      def assert_redirect_url(url=nil, message=nil) #:nodoc:
+        assert_redirect(message)
+        msg = build_message(message, "<?> is not the redirected location <?>", url, @response.redirect_url)
+        assert_block(msg) { @response.redirect_url == url }
+      end
+
+      # ensure our redirection url matches a pattern
+      def assert_redirect_url_match(pattern=nil, message=nil) #:nodoc:
+        assert_redirect(message)
+        msg = build_message(message, "<?> was not found in the location: <?>", pattern, @response.redirect_url)
+        assert_block(msg) { @response.redirect_url_match?(pattern) }
+      end
+
+    
+      # -- template assertions ------------------------------------------------
+
+      # ensure that a template object with the given name exists
+      def assert_template_has(key=nil, message=nil) #:nodoc:
+        msg = build_message(message, "<?> is not a template object", key )
+        assert_block(msg) { @response.has_template_object?(key) }
+      end
+
+      # ensure that a template object with the given name does not exist
+      def assert_template_has_no(key=nil,message=nil) #:nodoc:
+        msg = build_message(message, "<?> is a template object <?>", key, @response.template_objects[key])
+        assert_block(msg) { !@response.has_template_object?(key) }
+      end
+
+      # ensures that the object assigned to the template on +key+ is equal to +expected+ object.
+      def assert_template_equal(expected = nil, key = nil, message = nil) #:nodoc:
+        msg = build_message(message, "<?> expected in assigns['?'] but was <?>", expected, key, @response.template.assigns[key.to_s])
+        assert_block(msg) { expected == @response.template.assigns[key.to_s] }
+      end
+      alias_method :assert_assigned_equal, :assert_template_equal
+
+      # Asserts that the template returns the +expected+ string or array based on the XPath +expression+.
+      # This will only work if the template rendered a valid XML document.
+      def assert_template_xpath_match(expression=nil, expected=nil, message=nil) #:nodoc:
+        xml, matches = REXML::Document.new(@response.body), []
+        xml.elements.each(expression) { |e| matches << e.text }
+        if matches.empty? then
+          msg = build_message(message, "<?> not found in document", expression)
+          flunk(msg)
+          return
+        elsif matches.length < 2 then
+          matches = matches.first
+        end
+
+        msg = build_message(message, "<?> found <?>, not <?>", expression, matches, expected)
+        assert_block(msg) { matches == expected }
+      end
+
+      # Assert the template object with the given name is an Active Record descendant and is valid.
+      def assert_valid_record(key = nil, message = nil) #:nodoc:
+        record = find_record_in_template(key)
+        msg = build_message(message, "Active Record is invalid <?>)", record.errors.full_messages)
+        assert_block(msg) { record.valid? }
+      end
+
+      # Assert the template object with the given name is an Active Record descendant and is invalid.
+      def assert_invalid_record(key = nil, message = nil) #:nodoc:
+        record = find_record_in_template(key)
+        msg = build_message(message, "Active Record is valid)")
+        assert_block(msg) { !record.valid? }
+      end
+
+      # Assert the template object with the given name is an Active Record descendant and the specified column(s) are valid.
+      def assert_valid_column_on_record(key = nil, columns = "", message = nil) #:nodoc:
+        record = find_record_in_template(key)
+        record.send(:validate)
+
+        cols = glue_columns(columns)
+        cols.delete_if { |col| !record.errors.invalid?(col) }
+        msg = build_message(message, "Active Record has invalid columns <?>)", cols.join(",") )
+        assert_block(msg) { cols.empty? }
+      end
+
+      # Assert the template object with the given name is an Active Record descendant and the specified column(s) are invalid.
+      def assert_invalid_column_on_record(key = nil, columns = "", message = nil) #:nodoc:
+        record = find_record_in_template(key)
+        record.send(:validate)
+
+        cols = glue_columns(columns)
+        cols.delete_if { |col| record.errors.invalid?(col) }
+        msg = build_message(message, "Active Record has valid columns <?>)", cols.join(",") )
+        assert_block(msg) { cols.empty? }
+      end
+
+      private
+        def glue_columns(columns)
+          cols = []
+          cols << columns if columns.class == String
+          cols += columns if columns.class == Array
+          cols
+        end
+
+        def find_record_in_template(key = nil)
+          assert_template_has(key)
+          record = @response.template_objects[key]
+
+          assert_not_nil(record)
+          assert_kind_of ActiveRecord::Base, record
+
+          return record
+        end      
+    end
+  end
+end

data/lib/action_controller/flash.rb

@@ -24,7 +24,6 @@ module ActionController #:nodoc:
   #
   # See docs on the FlashHash class for more details about the flash.
   module Flash
-
     def self.append_features(base) #:nodoc:
       super
       base.before_filter(:fire_flash)
@@ -44,7 +43,6 @@ module ActionController #:nodoc:
     end
     
     class FlashHash < Hash
-    
       def initialize #:nodoc:
         super
         @used = {}
@@ -113,49 +111,45 @@ module ActionController #:nodoc:
       end
     
       private
-    
-      # Used internally by the <tt>keep</tt> and <tt>discard</tt> methods
-      #     use()               # marks the entire flash as used
-      #     use('msg')          # marks the "msg" entry as used
-      #     use(nil, false)     # marks the entire flash as unused (keeps it around for one more action)
-      #     use('msg', false)   # marks the "msg" entry as unused (keeps it around for one more action)
-      def use(k=nil, v=true)
-        unless k.nil?
-          @used[k] = v
-        else
-          keys.each{|key| use key, v }
+        # Used internally by the <tt>keep</tt> and <tt>discard</tt> methods
+        #     use()               # marks the entire flash as used
+        #     use('msg')          # marks the "msg" entry as used
+        #     use(nil, false)     # marks the entire flash as unused (keeps it around for one more action)
+        #     use('msg', false)   # marks the "msg" entry as unused (keeps it around for one more action)
+        def use(k=nil, v=true)
+          unless k.nil?
+            @used[k] = v
+          else
+            keys.each{|key| use key, v }
+          end
         end
-      end
-
     end
      
    
     protected 
+      # Access the contents of the flash. Use <tt>flash["notice"]</tt> to read a notice you put there or 
+      # <tt>flash["notice"] = "hello"</tt> to put a new one.
+      def flash #:doc:
+        @session['flash'] ||= FlashHash.new
+      end
   
-    # Access the contents of the flash. Use <tt>flash["notice"]</tt> to read a notice you put there or 
-    # <tt>flash["notice"] = "hello"</tt> to put a new one.
-    def flash #:doc:
-      @session['flash'] ||= FlashHash.new
-    end
-  
-    # deprecated. use <tt>flash.keep</tt> instead
-    def keep_flash #:doc:
-      flash.keep
-    end
-  
+      # deprecated. use <tt>flash.keep</tt> instead
+      def keep_flash #:doc:
+        flash.keep
+      end
   
-    private
   
-    # marks flash entries as used and expose the flash to the view 
-    def fire_flash
-      flash.discard
-      @assigns["flash"] = flash
-    end
+      private
   
-    # deletes the flash entries that were not marked for keeping
-    def sweep_flash
-      flash.sweep
-    end
+      # marks flash entries as used and expose the flash to the view 
+      def fire_flash
+        flash.discard
+        @assigns["flash"] = flash
+      end
   
+      # deletes the flash entries that were not marked for keeping
+      def sweep_flash
+        flash.sweep
+      end  
   end
 end