actionpack 2.2.3 → 2.3.2

data/lib/action_controller/verification.rb

@@ -90,7 +90,7 @@ module ActionController #:nodoc:
     def verify_action(options) #:nodoc:
       if prereqs_invalid?(options)
         flash.update(options[:add_flash])              if options[:add_flash]
-        response.headers.update(options[:add_headers]) if options[:add_headers]
+        response.headers.merge!(options[:add_headers]) if options[:add_headers]
         apply_remaining_actions(options)               unless performed?
       end
     end

data/lib/action_pack.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2008 David Heinemeier Hansson
+# Copyright (c) 2004-2009 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the

data/lib/action_pack/version.rb

@@ -1,8 +1,8 @@
 module ActionPack #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 2
-    MINOR = 2
-    TINY  = 3
+    MINOR = 3
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/action_view.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2008 David Heinemeier Hansson
+# Copyright (c) 2004-2009 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -31,23 +31,28 @@ rescue LoadError
   end
 end
 
-require 'action_view/template_handlers'
-require 'action_view/renderable'
-require 'action_view/renderable_partial'
+module ActionView
+  def self.load_all!
+    [Base, InlineTemplate, TemplateError]
+  end
 
-require 'action_view/template'
-require 'action_view/inline_template'
-require 'action_view/paths'
+  autoload :Base, 'action_view/base'
+  autoload :Helpers, 'action_view/helpers'
+  autoload :InlineTemplate, 'action_view/inline_template'
+  autoload :Partials, 'action_view/partials'
+  autoload :PathSet, 'action_view/paths'
+  autoload :Renderable, 'action_view/renderable'
+  autoload :RenderablePartial, 'action_view/renderable_partial'
+  autoload :Template, 'action_view/template'
+  autoload :ReloadableTemplate, 'action_view/reloadable_template'
+  autoload :TemplateError, 'action_view/template_error'
+  autoload :TemplateHandler, 'action_view/template_handler'
+  autoload :TemplateHandlers, 'action_view/template_handlers'
+  autoload :Helpers, 'action_view/helpers'
+end
 
-require 'action_view/base'
-require 'action_view/partials'
-require 'action_view/template_error'
+class ERB
+  autoload :Util, 'action_view/erb/util'
+end
 
 I18n.load_path << "#{File.dirname(__FILE__)}/action_view/locale/en.yml"
-
-require 'action_view/helpers'
-
-ActionView::Base.class_eval do
-  include ActionView::Partials
-  include ActionView::Helpers
-end

data/lib/action_view/base.rb

@@ -3,9 +3,12 @@ module ActionView #:nodoc:
   end
 
   class MissingTemplate < ActionViewError #:nodoc:
+    attr_reader :path
+
     def initialize(paths, path, template_format = nil)
+      @path = path
       full_template_path = path.include?('.') ? path : "#{path}.erb"
-      display_paths = paths.join(':')
+      display_paths = paths.compact.join(":")
       template_type = (path =~ /layouts/i) ? 'layout' : 'template'
       super("Missing #{template_type} #{full_template_path} in view path #{display_paths}")
     end
@@ -157,7 +160,7 @@ module ActionView #:nodoc:
   #
   # See the ActionView::Helpers::PrototypeHelper::GeneratorMethods documentation for more details.
   class Base
-    include ERB::Util
+    include Helpers, Partials, ::ERB::Util
     extend ActiveSupport::Memoizable
 
     attr_accessor :base_path, :assigns, :template_extension
@@ -172,25 +175,21 @@ module ActionView #:nodoc:
       delegate :logger, :to => 'ActionController::Base'
     end
 
-    # Templates that are exempt from layouts
-    @@exempt_from_layout = Set.new([/\.rjs$/])
-
-    # Don't render layouts for templates with the given extensions.
-    def self.exempt_from_layout(*extensions)
-      regexps = extensions.collect do |extension|
-        extension.is_a?(Regexp) ? extension : /\.#{Regexp.escape(extension.to_s)}$/
-      end
-      @@exempt_from_layout.merge(regexps)
-    end
-
+    @@debug_rjs = false
+    ##
+    # :singleton-method:
     # Specify whether RJS responses should be wrapped in a try/catch block
     # that alert()s the caught exception (and then re-raises it).
-    @@debug_rjs = false
     cattr_accessor :debug_rjs
 
-    # A warning will be displayed whenever an action results in a cache miss on your view paths.
-    @@warn_cache_misses = false
-    cattr_accessor :warn_cache_misses
+    # Specify whether templates should be cached. Otherwise the file we be read everytime it is accessed.
+    # Automatically reloading templates are not thread safe and should only be used in development mode.
+    @@cache_template_loading = nil
+    cattr_accessor :cache_template_loading
+
+    def self.cache_template_loading?
+      ActionController::Base.allow_concurrency || (cache_template_loading.nil? ? !ActiveSupport::Dependencies.load? : cache_template_loading)
+    end
 
     attr_internal :request
 
@@ -222,38 +221,43 @@ module ActionView #:nodoc:
     def initialize(view_paths = [], assigns_for_first_render = {}, controller = nil)#:nodoc:
       @assigns = assigns_for_first_render
       @assigns_added = nil
-      @_render_stack = []
       @controller = controller
       @helpers = ProxyModule.new(self)
       self.view_paths = view_paths
+
+      @_first_render = nil
+      @_current_render = nil
     end
 
     attr_reader :view_paths
 
     def view_paths=(paths)
       @view_paths = self.class.process_view_paths(paths)
+      # we might be using ReloadableTemplates, so we need to let them know this a new request
+      @view_paths.load!
     end
 
-    # Renders the template present at <tt>template_path</tt> (relative to the view_paths array).
-    # The hash in <tt>local_assigns</tt> is made available as local variables.
+    # Returns the result of a render that's dictated by the options hash. The primary options are:
+    #
+    # * <tt>:partial</tt> - See ActionView::Partials.
+    # * <tt>:update</tt> - Calls update_page with the block given.
+    # * <tt>:file</tt> - Renders an explicit template file (this used to be the old default), add :locals to pass in those.
+    # * <tt>:inline</tt> - Renders an inline template similar to how it's done in the controller.
+    # * <tt>:text</tt> - Renders the text passed in out.
+    #
+    # If no options hash is passed or :update specified, the default is to render a partial and use the second parameter
+    # as the locals hash.
     def render(options = {}, local_assigns = {}, &block) #:nodoc:
       local_assigns ||= {}
 
-      if options.is_a?(String)
-        ActiveSupport::Deprecation.warn(
-          "Calling render with a string will render a partial from Rails 2.3. " +
-          "Change this call to render(:file => '#{options}', :locals => locals_hash)."
-        )
-
-        render(:file => options, :locals => local_assigns)
-      elsif options == :update
-        update_page(&block)
-      elsif options.is_a?(Hash)
+      case options
+      when Hash
         options = options.reverse_merge(:locals => {})
         if options[:layout]
           _render_with_layout(options, local_assigns, &block)
         elsif options[:file]
-          _pick_template(options[:file]).render_template(self, options[:locals])
+          template = self.view_paths.find_template(options[:file], template_format)
+          template.render_template(self, options[:locals])
         elsif options[:partial]
           render_partial(options)
         elsif options[:inline]
@@ -261,6 +265,10 @@ module ActionView #:nodoc:
         elsif options[:text]
           options[:text]
         end
+      when :update
+        update_page(&block)
+      else
+        render_partial(:partial => options, :locals => local_assigns)
       end
     end
 
@@ -271,7 +279,7 @@ module ActionView #:nodoc:
       if defined? @template_format
         @template_format
       elsif controller && controller.respond_to?(:request)
-        @template_format = controller.request.template_format
+        @template_format = controller.request.template_format.to_sym
       else
         @template_format = :html
       end
@@ -280,7 +288,19 @@ module ActionView #:nodoc:
     # Access the current template being rendered.
     # Returns a ActionView::Template object.
     def template
-      @_render_stack.last
+      @_current_render
+    end
+
+    def template=(template) #:nodoc:
+      @_first_render ||= template
+      @_current_render = template
+    end
+
+    def with_template(current_template)
+      last_template, self.template = template, current_template
+      yield
+    ensure
+      self.template = last_template
     end
 
     private
@@ -307,52 +327,6 @@ module ActionView #:nodoc:
         end
       end
 
-      def _pick_template(template_path)
-        return template_path if template_path.respond_to?(:render)
-
-        path = template_path.sub(/^\//, '')
-        if m = path.match(/(.*)\.(\w+)$/)
-          template_file_name, template_file_extension = m[1], m[2]
-        else
-          template_file_name = path
-        end
-
-        # OPTIMIZE: Checks to lookup template in view path
-        if template = self.view_paths["#{template_file_name}.#{template_format}"]
-          template
-        elsif template_file_extension && template = self.view_paths["#{template_file_name}.#{template_file_extension}"]
-          template
-        elsif template = self.view_paths[template_file_name]
-          template
-        elsif (first_render = @_render_stack.first) && first_render.respond_to?(:format_and_extension) &&
-            (template = self.view_paths["#{template_file_name}.#{first_render.format_and_extension}"])
-          template
-        elsif template_format == :js && template = self.view_paths["#{template_file_name}.html"]
-          @template_format = :html
-          template
-        else
-          template = Template.new(template_path, view_paths)
-
-          if self.class.warn_cache_misses && logger
-            logger.debug "[PERFORMANCE] Rendering a template that was " +
-              "not found in view path. Templates outside the view path are " +
-              "not cached and result in expensive disk operations. Move this " +
-              "file into #{view_paths.join(':')} or add the folder to your " +
-              "view path list"
-          end
-
-          template
-        end
-      end
-      memoize :_pick_template
-
-      def _exempt_from_layout?(template_path) #:nodoc:
-        template = _pick_template(template_path).to_s
-        @@exempt_from_layout.any? { |ext| template =~ ext }
-      rescue ActionView::MissingTemplate
-        return false
-      end
-
       def _render_with_layout(options, local_assigns, &block) #:nodoc:
         partial_layout = options.delete(:layout)
 

data/lib/action_view/erb/util.rb

@@ -0,0 +1,38 @@
+require 'erb'
+
+class ERB
+  module Util
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
+    JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
+
+    # A utility method for escaping HTML tag characters.
+    # This method is also aliased as <tt>h</tt>.
+    #
+    # In your ERb templates, use this method to escape any unsafe content. For example:
+    #   <%=h @person.name %>
+    #
+    # ==== Example:
+    #   puts html_escape("is a > 0 & a < 10?")
+    #   # => is a &gt; 0 &amp; a &lt; 10?
+    def html_escape(s)
+      s.to_s.gsub(/[&"><]/) { |special| HTML_ESCAPE[special] }
+    end
+
+    # A utility method for escaping HTML entities in JSON strings.
+    # This method is also aliased as <tt>j</tt>.
+    #
+    # In your ERb templates, use this method to escape any HTML entities:
+    #   <%=j @person.to_json %>
+    #
+    # ==== Example:
+    #   puts json_escape("is a > 0 & a < 10?")
+    #   # => is a \u003E 0 \u0026 a \u003C 10?
+    def json_escape(s)
+      s.to_s.gsub(/[&"><]/) { |special| JSON_ESCAPE[special] }
+    end
+
+    alias j json_escape
+    module_function :j
+    module_function :json_escape
+  end
+end

data/lib/action_view/helpers.rb

@@ -1,10 +1,28 @@
-Dir.entries(File.expand_path("#{File.dirname(__FILE__)}/helpers")).sort.each do |file|
-  next unless file =~ /^([a-z][a-z_]*_helper).rb$/
-  require "action_view/helpers/#{$1}"
-end
-
 module ActionView #:nodoc:
   module Helpers #:nodoc:
+    autoload :ActiveRecordHelper, 'action_view/helpers/active_record_helper'
+    autoload :AssetTagHelper, 'action_view/helpers/asset_tag_helper'
+    autoload :AtomFeedHelper, 'action_view/helpers/atom_feed_helper'
+    autoload :BenchmarkHelper, 'action_view/helpers/benchmark_helper'
+    autoload :CacheHelper, 'action_view/helpers/cache_helper'
+    autoload :CaptureHelper, 'action_view/helpers/capture_helper'
+    autoload :DateHelper, 'action_view/helpers/date_helper'
+    autoload :DebugHelper, 'action_view/helpers/debug_helper'
+    autoload :FormHelper, 'action_view/helpers/form_helper'
+    autoload :FormOptionsHelper, 'action_view/helpers/form_options_helper'
+    autoload :FormTagHelper, 'action_view/helpers/form_tag_helper'
+    autoload :JavascriptHelper, 'action_view/helpers/javascript_helper'
+    autoload :NumberHelper, 'action_view/helpers/number_helper'
+    autoload :PrototypeHelper, 'action_view/helpers/prototype_helper'
+    autoload :RecordIdentificationHelper, 'action_view/helpers/record_identification_helper'
+    autoload :RecordTagHelper, 'action_view/helpers/record_tag_helper'
+    autoload :SanitizeHelper, 'action_view/helpers/sanitize_helper'
+    autoload :ScriptaculousHelper, 'action_view/helpers/scriptaculous_helper'
+    autoload :TagHelper, 'action_view/helpers/tag_helper'
+    autoload :TextHelper, 'action_view/helpers/text_helper'
+    autoload :TranslationHelper, 'action_view/helpers/translation_helper'
+    autoload :UrlHelper, 'action_view/helpers/url_helper'
+
     def self.included(base)
       base.extend(ClassMethods)
     end
@@ -24,6 +42,7 @@ module ActionView #:nodoc:
     include FormHelper
     include FormOptionsHelper
     include FormTagHelper
+    include JavaScriptHelper
     include NumberHelper
     include PrototypeHelper
     include RecordIdentificationHelper

data/lib/action_view/helpers/active_record_helper.rb

@@ -121,7 +121,7 @@ module ActionView
         if (obj = (object.respond_to?(:errors) ? object : instance_variable_get("@#{object}"))) &&
           (errors = obj.errors.on(method))
           content_tag("div",
-            "#{options[:prepend_text]}#{errors.is_a?(Array) ? errors.first : errors}#{options[:append_text]}",
+            "#{options[:prepend_text]}#{ERB::Util.html_escape(errors.is_a?(Array) ? errors.first : errors)}#{options[:append_text]}",
             :class => options[:css_class]
           )
         else
@@ -198,7 +198,7 @@ module ActionView
               locale.t :header, :count => count, :model => object_name
             end
             message = options.include?(:message) ? options[:message] : locale.t(:body)
-            error_messages = objects.sum {|object| object.errors.full_messages.map {|msg| content_tag(:li, msg) } }.join
+            error_messages = objects.sum {|object| object.errors.full_messages.map {|msg| content_tag(:li, ERB::Util.html_escape(msg)) } }.join
 
             contents = ''
             contents << content_tag(options[:header_tag] || :h2, header_message) unless header_message.blank?

data/lib/action_view/helpers/asset_tag_helper.rb

@@ -6,54 +6,70 @@ module ActionView
   module Helpers #:nodoc:
     # This module provides methods for generating HTML that links views to assets such
     # as images, javascripts, stylesheets, and feeds. These methods do not verify
-    # the assets exist before linking to them.
+    # the assets exist before linking to them:
+    #
+    #   image_tag("rails.png")
+    #   # => <img alt="Rails src="/images/rails.png?1230601161" />
+    #   stylesheet_link_tag("application")
+    #   # => <link href="/stylesheets/application.css?1232285206" media="screen" rel="stylesheet" type="text/css" />
     #
     # === Using asset hosts
+    #
     # By default, Rails links to these assets on the current host in the public
-    # folder, but you can direct Rails to link to assets from a dedicated assets server by
-    # setting ActionController::Base.asset_host in your <tt>config/environment.rb</tt>.  For example,
-    # let's say your asset host is <tt>assets.example.com</tt>.
+    # folder, but you can direct Rails to link to assets from a dedicated asset
+    # server by setting ActionController::Base.asset_host in the application
+    # configuration, typically in <tt>config/environments/production.rb</tt>.
+    # For example, you'd define <tt>assets.example.com</tt> to be your asset
+    # host this way:
     #
     #   ActionController::Base.asset_host = "assets.example.com"
+    #
+    # Helpers take that into account:
+    #
     #   image_tag("rails.png")
-    #     => <img src="http://assets.example.com/images/rails.png" alt="Rails" />
+    #   # => <img alt="Rails" src="http://assets.example.com/images/rails.png?1230601161" />
     #   stylesheet_link_tag("application")
-    #     => <link href="http://assets.example.com/stylesheets/application.css" media="screen" rel="stylesheet" type="text/css" />
+    #   # => <link href="http://assets.example.com/stylesheets/application.css?1232285206" media="screen" rel="stylesheet" type="text/css" />
     #
-    # This is useful since browsers typically open at most two connections to a single host,
-    # which means your assets often wait in single file for their turn to load.  You can
-    # alleviate this by using a <tt>%d</tt> wildcard in <tt>asset_host</tt> (for example, "assets%d.example.com")
-    # to automatically distribute asset requests among four hosts (e.g., "assets0.example.com" through "assets3.example.com")
-    # so browsers will open eight connections rather than two.
+    # Browsers typically open at most two simultaneous connections to a single
+    # host, which means your assets often have to wait for other assets to finish
+    # downloading. You can alleviate this by using a <tt>%d</tt> wildcard in the
+    # +asset_host+. For example, "assets%d.example.com". If that wildcard is
+    # present Rails distributes asset requests among the corresponding four hosts
+    # "assets0.example.com", ..., "assets3.example.com". With this trick browsers
+    # will open eight simultaneous connections rather than two.
     #
     #   image_tag("rails.png")
-    #     => <img src="http://assets0.example.com/images/rails.png" alt="Rails" />
+    #   # => <img alt="Rails" src="http://assets0.example.com/images/rails.png?1230601161" />
     #   stylesheet_link_tag("application")
-    #     => <link href="http://assets3.example.com/stylesheets/application.css" media="screen" rel="stylesheet" type="text/css" />
+    #   # => <link href="http://assets2.example.com/stylesheets/application.css?1232285206" media="screen" rel="stylesheet" type="text/css" />
     #
-    # To do this, you can either setup 4 actual hosts, or you can use wildcard DNS to CNAME
-    # the wildcard to a single asset host.  You can read more about setting up your DNS CNAME records from
-    # your ISP.
+    # To do this, you can either setup four actual hosts, or you can use wildcard
+    # DNS to CNAME the wildcard to a single asset host. You can read more about
+    # setting up your DNS CNAME records from your ISP.
     #
     # Note: This is purely a browser performance optimization and is not meant
     # for server load balancing. See http://www.die.net/musings/page_load_time/
     # for background.
     #
-    # Alternatively, you can exert more control over the asset host by setting <tt>asset_host</tt> to a proc
-    # that takes a single source argument. This is useful if you are unable to setup 4 actual hosts or have
-    # fewer/more than 4 hosts. The example proc below generates http://assets1.example.com and
-    # http://assets2.example.com randomly.
+    # Alternatively, you can exert more control over the asset host by setting
+    # +asset_host+ to a proc like this:
     #
-    #   ActionController::Base.asset_host = Proc.new { |source| "http://assets#{rand(2) + 1}.example.com" }
+    #   ActionController::Base.asset_host = Proc.new { |source|
+    #     "http://assets#{rand(2) + 1}.example.com"
+    #   }
     #   image_tag("rails.png")
-    #     => <img src="http://assets2.example.com/images/rails.png" alt="Rails" />
+    #   # => <img alt="Rails" src="http://assets0.example.com/images/rails.png?1230601161" />
     #   stylesheet_link_tag("application")
-    #     => <link href="http://assets1.example.com/stylesheets/application.css" media="screen" rel="stylesheet" type="text/css" />
+    #   # => <link href="http://assets1.example.com/stylesheets/application.css?1232285206" media="screen" rel="stylesheet" type="text/css" />
+    #
+    # The example above generates "http://assets1.example.com" and
+    # "http://assets2.example.com" randomly. This option is useful for example if
+    # you need fewer/more than four hosts, custom host names, etc.
     #
-    # The proc takes a <tt>source</tt> parameter (which is the path of the source asset) and an optional
-    # <tt>request</tt> parameter (which is an entire instance of an <tt>ActionController::AbstractRequest</tt>
-    # subclass). This can be used to generate a particular asset host depending on the asset path and the particular
-    # request.
+    # As you see the proc takes a +source+ parameter. That's a string with the
+    # absolute path of the asset with any extensions and timestamps in place,
+    # for example "/images/rails.png?1230601161".
     #
     #    ActionController::Base.asset_host = Proc.new { |source|
     #      if source.starts_with?('/images')
@@ -63,14 +79,16 @@ module ActionView
     #      end
     #    }
     #   image_tag("rails.png")
-    #     => <img src="http://images.example.com/images/rails.png" alt="Rails" />
+    #   # => <img alt="Rails" src="http://images.example.com/images/rails.png?1230601161" />
     #   stylesheet_link_tag("application")
-    #     => <link href="http://assets.example.com/stylesheets/application.css" media="screen" rel="stylesheet" type="text/css" />
+    #   # => <link href="http://assets.example.com/stylesheets/application.css?1232285206" media="screen" rel="stylesheet" type="text/css" />
     #
-    # The optional <tt>request</tt> parameter to the proc is useful in particular for serving assets from an
-    # SSL-protected page. The example proc below disables asset hosting for HTTPS connections, while still sending
-    # assets for plain HTTP requests from asset hosts. This is useful for avoiding mixed media warnings when serving
-    # non-HTTP assets from HTTPS web pages when you don't have an SSL certificate for each of the asset hosts.
+    # Alternatively you may ask for a second parameter +request+. That one is
+    # particularly useful for serving assets from an SSL-protected page. The
+    # example proc below disables asset hosting for HTTPS connections, while
+    # still sending assets for plain HTTP requests from asset hosts. If you don't
+    # have SSL certificates for each of the asset hosts this technique allows you
+    # to avoid warnings in the client about mixed media.
     #
     #   ActionController::Base.asset_host = Proc.new { |source, request|
     #     if request.ssl?
@@ -80,26 +98,38 @@ module ActionView
     #     end
     #   }
     #
+    # You can also implement a custom asset host object that responds to +call+
+    # and takes either one or two parameters just like the proc.
+    #
+    #   config.action_controller.asset_host = AssetHostingWithMinimumSsl.new(
+    #     "http://asset%d.example.com", "https://asset1.example.com"
+    #   )
+    #
     # === Using asset timestamps
     #
-    # By default, Rails will append all asset paths with that asset's timestamp. This allows you to set a cache-expiration date for the
-    # asset far into the future, but still be able to instantly invalidate it by simply updating the file (and hence updating the timestamp,
-    # which then updates the URL as the timestamp is part of that, which in turn busts the cache).
+    # By default, Rails appends asset's timestamps to all asset paths. This allows
+    # you to set a cache-expiration date for the asset far into the future, but
+    # still be able to instantly invalidate it by simply updating the file (and
+    # hence updating the timestamp, which then updates the URL as the timestamp
+    # is part of that, which in turn busts the cache).
     #
-    # It's the responsibility of the web server you use to set the far-future expiration date on cache assets that you need to take
-    # advantage of this feature. Here's an example for Apache:
+    # It's the responsibility of the web server you use to set the far-future
+    # expiration date on cache assets that you need to take advantage of this
+    # feature. Here's an example for Apache:
     #
-    # # Asset Expiration
-    # ExpiresActive On
-    # <FilesMatch "\.(ico|gif|jpe?g|png|js|css)$">
-    #   ExpiresDefault "access plus 1 year"
-    # </FilesMatch>
+    #   # Asset Expiration
+    #   ExpiresActive On
+    #   <FilesMatch "\.(ico|gif|jpe?g|png|js|css)$">
+    #     ExpiresDefault "access plus 1 year"
+    #   </FilesMatch>
     #
-    # Also note that in order for this to work, all your application servers must return the same timestamps. This means that they must
-    # have their clocks synchronized. If one of them drift out of sync, you'll see different timestamps at random and the cache won't
-    # work. Which means that the browser will request the same assets over and over again even thought they didn't change. You can use
-    # something like Live HTTP Headers for Firefox to verify that the cache is indeed working (and that the assets are not being
-    # requested over and over).
+    # Also note that in order for this to work, all your application servers must
+    # return the same timestamps. This means that they must have their clocks
+    # synchronized. If one of them drifts out of sync, you'll see different
+    # timestamps at random and the cache won't work. In that case the browser
+    # will request the same assets over and over again even thought they didn't
+    # change. You can use something like Live HTTP Headers for Firefox to verify
+    # that the cache is indeed working.
     module AssetTagHelper
       ASSETS_DIR      = defined?(Rails.public_path) ? Rails.public_path : "public"
       JAVASCRIPTS_DIR = "#{ASSETS_DIR}/javascripts"
@@ -111,7 +141,7 @@ module ActionView
       # <tt>:atom</tt>. Control the link options in url_for format using the
       # +url_options+. You can modify the LINK tag itself in +tag_options+.
       #
-      # ==== Options:
+      # ==== Options
       # * <tt>:rel</tt>  - Specify the relation of this link, defaults to "alternate"
       # * <tt>:type</tt>  - Override the auto-generated mime type
       # * <tt>:title</tt>  - Specify the title of the link, defaults to the +type+
@@ -486,7 +516,8 @@ module ActionView
         def compute_public_path(source, dir, ext = nil, include_host = true)
           has_request = @controller.respond_to?(:request)
 
-          if ext && (File.extname(source).blank? || File.exist?(File.join(ASSETS_DIR, dir, "#{source}.#{ext}")))
+          source_ext = File.extname(source)[1..-1]
+          if ext && (source_ext.blank? || (ext != source_ext && File.exist?(File.join(ASSETS_DIR, dir, "#{source}.#{ext}"))))
             source += ".#{ext}"
           end