actionpack 3.0.20 → 3.1.0.beta1

data/lib/action_view/locale/en.yml

@@ -5,7 +5,7 @@
     format:
       # Sets the separator between the units, for more precision (e.g. 1.0 / 2.0 == 0.5)
       separator: "."
-      # Delimets thousands (e.g. 1,000,000 is a million) (always in groups of three)
+      # Delimits thousands (e.g. 1,000,000 is a million) (always in groups of three)
       delimiter: ","
       # Number of decimals, behind the separator (the number 1 with a precision of 2 gives: 1.00)
       precision: 3

data/lib/action_view/lookup_context.rb

@@ -9,8 +9,10 @@ module ActionView
   # generate a key, given to view paths, used in the resolver cache lookup. Since
   # this key is generated just once during the request, it speeds up all cache accesses.
   class LookupContext #:nodoc:
+    attr_accessor :prefixes
+    
     mattr_accessor :fallbacks
-    @@fallbacks = [FileSystemResolver.new(""), FileSystemResolver.new("/")]
+    @@fallbacks = FallbackFileSystemResolver.instances
 
     mattr_accessor :registered_details
     self.registered_details = []
@@ -58,9 +60,11 @@ module ActionView
       end
     end
 
-    def initialize(view_paths, details = {})
+    def initialize(view_paths, details = {}, prefixes = [])
       @details, @details_key = { :handlers => default_handlers }, nil
       @frozen_formats, @skip_default_locale = false, false
+      @cache = true
+      @prefixes = prefixes
 
       self.view_paths = view_paths
       self.registered_detail_setters.each do |key, setter|
@@ -77,17 +81,17 @@ module ActionView
         @view_paths = ActionView::Base.process_view_paths(paths)
       end
 
-      def find(name, prefix = nil, partial = false)
-        @view_paths.find(*args_for_lookup(name, prefix, partial))
+      def find(name, prefixes = [], partial = false, keys = [])
+        @view_paths.find(*args_for_lookup(name, prefixes, partial, keys))
       end
       alias :find_template :find
 
-      def find_all(name, prefix = nil, partial = false)
-        @view_paths.find_all(*args_for_lookup(name, prefix, partial))
+      def find_all(name, prefixes = [], partial = false, keys = [])
+        @view_paths.find_all(*args_for_lookup(name, prefixes, partial, keys))
       end
 
-      def exists?(name, prefix = nil, partial = false)
-        @view_paths.exists?(*args_for_lookup(name, prefix, partial))
+      def exists?(name, prefixes = [], partial = false, keys = [])
+        @view_paths.exists?(*args_for_lookup(name, prefixes, partial, keys))
       end
       alias :template_exists? :exists?
 
@@ -106,18 +110,26 @@ module ActionView
 
     protected
 
-      def args_for_lookup(name, prefix, partial) #:nodoc:
-        name, prefix = normalize_name(name, prefix)
-        [name, prefix, partial || false, @details, details_key]
+      def args_for_lookup(name, prefixes, partial, keys) #:nodoc:
+        name, prefixes = normalize_name(name, prefixes)
+        [name, prefixes, partial || false, @details, details_key, keys]
       end
 
       # Support legacy foo.erb names even though we now ignore .erb
       # as well as incorrectly putting part of the path in the template
       # name instead of the prefix.
-      def normalize_name(name, prefix) #:nodoc:
+      def normalize_name(name, prefixes) #:nodoc:
         name  = name.to_s.gsub(handlers_regexp, '')
         parts = name.split('/')
-        return parts.pop, [prefix, *parts].compact.join("/")
+        name  = parts.pop
+
+        prefixes = if prefixes.blank?
+          [parts.join('/')]
+        else
+          prefixes.map { |prefix| [prefix, *parts].compact.join('/') }
+        end
+
+        return name, prefixes
       end
 
       def default_handlers #:nodoc:
@@ -130,10 +142,20 @@ module ActionView
     end
 
     module Details
+      attr_accessor :cache
+
       # Calculate the details key. Remove the handlers from calculation to improve performance
       # since the user cannot modify it explicitly.
       def details_key #:nodoc:
-        @details_key ||= DetailsKey.get(@details)
+        @details_key ||= DetailsKey.get(@details) if @cache
+      end
+
+      # Temporary skip passing the details_key forward.
+      def disable_cache
+        old_value, @cache = @cache, false
+        yield
+      ensure
+        @cache = old_value
       end
 
       # Freeze the current formats in the lookup context. By freezing them, you are guaranteeing

data/lib/action_view/{paths.rb → path_set.rb}

@@ -10,16 +10,17 @@ module ActionView #:nodoc:
       METHOD
     end
 
-    def find(path, prefix = nil, partial = false, details = {}, key = nil)
-      template = find_all(path, prefix, partial, details, key).first
-      raise MissingTemplate.new(self, "#{prefix}/#{path}", details, partial) unless template
-      template
+    def find(*args)
+      find_all(*args).first || raise(MissingTemplate.new(self, *args))
     end
 
-    def find_all(*args)
-      each do |resolver|
-        templates = resolver.find_all(*args)
-        return templates unless templates.empty?
+    def find_all(path, prefixes = [], *args)
+      prefixes = [prefixes] if String === prefixes
+      prefixes.each do |prefix|
+        each do |resolver|
+          templates = resolver.find_all(path, prefix, *args)
+          return templates unless templates.empty?
+        end
       end
       []
     end

data/lib/action_view/railtie.rb

@@ -6,12 +6,12 @@ module ActionView
   class Railtie < Rails::Railtie
     config.action_view = ActiveSupport::OrderedOptions.new
     config.action_view.stylesheet_expansions = {}
-    config.action_view.javascript_expansions = { :defaults => ['prototype', 'effects', 'dragdrop', 'controls', 'rails'] }
+    config.action_view.javascript_expansions = { :defaults => %w(jquery jquery_ujs) }
 
-    initializer "action_view.cache_asset_timestamps" do |app|
+    initializer "action_view.cache_asset_ids" do |app|
       unless app.config.cache_classes
         ActiveSupport.on_load(:action_view) do
-          ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
+          ActionView::Helpers::AssetTagHelper::AssetPaths.cache_asset_ids = false
         end
       end
     end
@@ -35,5 +35,13 @@ module ActionView
         end
       end
     end
+
+    initializer "action_view.caching" do |app|
+      ActiveSupport.on_load(:action_view) do
+        if app.config.action_view.cache_template_loading.nil?
+          ActionView::Resolver.caching = app.config.cache_classes
+        end
+      end
+    end
   end
-end
+end

data/lib/action_view/renderer/abstract_renderer.rb

@@ -0,0 +1,36 @@
+module ActionView
+  class AbstractRenderer #:nodoc:
+    delegate :find_template, :template_exists?, :with_fallbacks, :update_details,
+      :with_layout_format, :formats, :freeze_formats, :to => :@lookup_context
+
+    def initialize(lookup_context)
+      @lookup_context = lookup_context
+    end
+
+    def render
+      raise NotImplementedError
+    end
+
+    # Checks if the given path contains a format and if so, change
+    # the lookup context to take this new format into account.
+    def wrap_formats(value)
+      return yield unless value.is_a?(String)
+
+      if value.sub!(formats_regexp, "")
+        update_details(:formats => [$1.to_sym]){ yield }
+      else
+        yield
+      end
+    end
+
+    def formats_regexp
+      @@formats_regexp ||= /\.(#{Mime::SET.symbols.join('|')})$/
+    end
+
+    protected
+
+    def instrument(name, options={})
+      ActiveSupport::Notifications.instrument("render_#{name}.action_view", options){ yield }
+    end
+  end
+end

data/lib/action_view/{render/partials.rb → renderer/partial_renderer.rb}

@@ -12,50 +12,49 @@ module ActionView
   #
   #  <%= render :partial => "account" %>
   #
-  # This would render "advertiser/_account.erb" and pass the instance variable @account in as a local variable
+  # This would render "advertiser/_account.html.erb" and pass the instance variable @account in as a local variable
   # +account+ to the template for display.
   #
   # In another template for Advertiser#buy, we could have:
   #
   #   <%= render :partial => "account", :locals => { :account => @buyer } %>
   #
-  #   <% for ad in @advertisements %>
+  #   <% @advertisements.each do |ad| %>
   #     <%= render :partial => "ad", :locals => { :ad => ad } %>
   #   <% end %>
   #
-  # This would first render "advertiser/_account.erb" with @buyer passed in as the local variable +account+, then
-  # render "advertiser/_ad.erb" and pass the local variable +ad+ to the template for display.
+  # This would first render "advertiser/_account.html.erb" with @buyer passed in as the local variable +account+, then
+  # render "advertiser/_ad.html.erb" and pass the local variable +ad+ to the template for display.
   #
   # == The :as and :object options
   #
-  # By default PartialRenderer uses the template name for the local name of the object passed into the template.
-  # These examples are effectively the same:
-  #
-  #   <%= render :partial => "contract", :locals => { :contract  => @contract } %>
+  # By default <tt>ActionView::Partials::PartialRenderer</tt> has its object in a local variable with the same
+  # name as the template. So, given
   #
   #   <%= render :partial => "contract" %>
   #
-  # By specifying the :as option we can change the way the local variable is namedin the template.
-  # These examples are effectively the same:
+  # within contract we'll get <tt>@contract</tt> in the local variable +contract+, as if we had written
+  #
+  #   <%= render :partial => "contract", :locals => { :contract  => @contract } %>
   #
-  #   <%= render :partial => "contract", :as => :agreement
+  # With the <tt>:as</tt> option we can specify a different name for said local variable. For example, if we
+  # wanted it to be +agreement+ instead of +contract+ we'd do:
   #
-  #   <%= render :partial => "contract", :locals => { :agreement => @contract }
+  #   <%= render :partial => "contract", :as => 'agreement' %>
   #
-  # The :object option can be used to directly specify which object is rendered into the partial.
+  # The <tt>:object</tt> option can be used to directly specify which object is rendered into the partial;
+  # useful when the template's object is elsewhere, in a different ivar or in a local variable for instance.
   #
-  # Revisiting a previous example we could have written this code.
+  # Revisiting a previous example we could have written this code:
   #
   #   <%= render :partial => "account", :object => @buyer %>
   #
-  #   <% for ad in @advertisements %>
+  #   <% @advertisements.each do |ad| %>
   #     <%= render :partial => "ad", :object => ad %>
   #   <% end %>
   #
-  # The :object and :as options can be used together. We might have a partial which we have named genericly,
-  # such as 'form'. Using :object and :as together helps us.
+  # The <tt>:object</tt> and <tt>:as</tt> options can be used together.
   #
-  #   <%= render :partial => "form", :object => @contract, :as => :contract %>
   # == Rendering a collection of partials
   #
   # The example of partial use describes a familiar pattern where a template needs to iterate over an array and
@@ -65,17 +64,22 @@ module ActionView
   #
   #   <%= render :partial => "ad", :collection => @advertisements %>
   #
-  # This will render "advertiser/_ad.erb" and pass the local variable +ad+ to the template for display. An
+  # This will render "advertiser/_ad.html.erb" and pass the local variable +ad+ to the template for display. An
   # iteration counter will automatically be made available to the template with a name of the form
   # +partial_name_counter+. In the case of the example above, the template would be fed +ad_counter+.
   #
-  # The :as option may be used when rendering partials.
+  # The <tt>:as</tt> option may be used when rendering partials.
   #
-  # Also, you can specify a partial which will be render as a spacer between each element by passing partial name to
-  # +:spacer_template+. The following example will render "advertiser/_ad_divider.erb" between each ad partial.
+  # You can specify a partial to be rendered between elements via the <tt>:spacer_template</tt> option.
+  # The following example will render <tt>advertiser/_ad_divider.html.erb</tt> between each ad partial:
   #
   #   <%= render :partial => "ad", :collection => @advertisements, :spacer_template => "ad_divider" %>
   #
+  # If the given <tt>:collection</tt> is nil or empty, <tt>render</tt> will return nil. This will allow you
+  # to specify a text which will displayed instead by using this form:
+  #
+  #   <%= render(:partial => "ad", :collection => @advertisements) || "There's no ad to be displayed" %>
+  #
   # NOTE: Due to backwards compatibility concerns, the collection can't be one of hashes. Normally you'd also
   # just keep domain objects, like Active Records, in there.
   #
@@ -85,7 +89,7 @@ module ActionView
   #
   #   <%= render :partial => "advertisement/ad", :locals => { :ad => @advertisement } %>
   #
-  # This will render the partial "advertisement/_ad.erb" regardless of which controller this is being called from.
+  # This will render the partial "advertisement/_ad.html.erb" regardless of which controller this is being called from.
   #
   # == Rendering objects with the RecordIdentifier
   #
@@ -210,173 +214,170 @@ module ActionView
   #       Deadline: <%= user.deadline %>
   #     <%- end -%>
   #   <% end %>
-  module Partials
-    extend ActiveSupport::Concern
-
-    class PartialRenderer
-      PARTIAL_NAMES = Hash.new {|h,k| h[k] = {} }
-
-      def initialize(view_context, options, block)
-        @view           = view_context
-        @partial_names  = PARTIAL_NAMES[@view.controller.class.name]
+  class PartialRenderer < AbstractRenderer #:nodoc:
+    PARTIAL_NAMES = Hash.new {|h,k| h[k] = {} }
 
-        setup(options, block)
-      end
-
-      def setup(options, block)
-        partial = options[:partial]
-
-        @options = options
-        @locals  = options[:locals] || {}
-        @block   = block
+    def initialize(*)
+      super
+      @partial_names = PARTIAL_NAMES[@lookup_context.prefixes.first]
+    end
 
-        if String === partial
-          @object     = options[:object]
-          @path       = partial
-          @collection = collection
-        else
-          @object = partial
+    def render(context, options, block)
+      setup(context, options, block)
 
-          if @collection = collection_from_object || collection
-            paths = @collection_paths = @collection.map { |o| partial_path(o) }
-            @path = paths.uniq.size == 1 ? paths.first : nil
-          else
-            @path = partial_path
-          end
-        end
-      end
-
-      def render
-        identifier = ((@template = find_template) ? @template.identifier : @path)
+      wrap_formats(@path) do
+        identifier = ((@template = find_partial) ? @template.identifier : @path)
 
         if @collection
-          ActiveSupport::Notifications.instrument("render_collection.action_view",
-            :identifier => identifier || "collection", :count => @collection.size) do
+          instrument(:collection, :identifier => identifier || "collection", :count => @collection.size) do
             render_collection
           end
         else
-          block, options, locals = @block, @options, @locals
-
-          content = ActiveSupport::Notifications.instrument("render_partial.action_view",
-            :identifier => identifier) do
+          instrument(:partial, :identifier => identifier) do
             render_partial
           end
-
-          if !block && (layout = options[:layout])
-            content = @view._render_layout(find_template(layout), locals){ content }
-          end
-
-          content
         end
       end
+    end
 
-      def render_collection
-        return nil if @collection.blank?
-
-        if @options.key?(:spacer_template)
-          spacer = find_template(@options[:spacer_template]).render(@view, @locals)
-        end
+    def render_collection
+      return nil if @collection.blank?
 
-        result = @template ? collection_with_template : collection_without_template
-        result.join(spacer).html_safe
+      if @options.key?(:spacer_template)
+        spacer = find_template(@options[:spacer_template]).render(@view, @locals)
       end
 
-      def collection_with_template(template = @template)
-        segments, locals, template = [], @locals, @template
-
-        if @options[:as]
-          as = @options[:as]
-          counter = "#{as}_counter".to_sym
-        else
-          as = template.variable_name
-          counter = template.counter_name
-        end
-
-        locals[counter] = -1
+      result = @template ? collection_with_template : collection_without_template
+      result.join(spacer).html_safe
+    end
 
-        @collection.each do |object|
-          locals[counter] += 1
-          locals[as] = object
-          segments << template.render(@view, locals)
-        end
+    def render_partial
+      locals, view, block = @locals, @view, @block
+      object, as = @object, @variable
 
-        segments
+      if !block && (layout = @options[:layout])
+        layout = find_template(layout)
       end
 
-      def collection_without_template(collection_paths = @collection_paths)
-        segments, locals = [], @locals
-        index, template  = -1, nil
+      object ||= locals[as]
+      locals[as] = object
 
-        if @options[:as]
-          as = @options[:as]
-          counter = "#{as}_counter"
-        end
+      content = @template.render(view, locals) do |*name|
+        view._layout_for(*name, &block)
+      end
 
-        @collection.each_with_index do |object, i|
-          template = find_template(collection_paths[i])
-          locals[as || template.variable_name] = object
-          locals[counter || template.counter_name] = (index += 1)
+      content = layout.render(view, locals){ content } if layout
+      content
+    end
 
-          segments << template.render(@view, locals)
-        end
+    private
 
-        @template = template
-        segments
-      end
+    def setup(context, options, block)
+      @view   = context
+      partial = options[:partial]
 
-      def render_partial(object = @object)
-        locals, view, template, block = @locals, @view, @template, @block
+      @options = options
+      @locals  = options[:locals] || {}
+      @block   = block
 
-        object ||= locals[template.variable_name]
-        locals[@options[:as] || template.variable_name] = object
+      if String === partial
+        @object     = options[:object]
+        @path       = partial
+        @collection = collection
+      else
+        @object = partial
 
-        template.render(view, locals) do |*name|
-          view._layout_for(*name, &block)
+        if @collection = collection_from_object || collection
+          paths = @collection_data = @collection.map { |o| partial_path(o) }
+          @path = paths.uniq.size == 1 ? paths.first : nil
+        else
+          @path = partial_path
         end
       end
 
-    private
+      if @path
+        @variable, @variable_counter = retrieve_variable(@path)
+      else
+        paths.map! { |path| retrieve_variable(path).unshift(path) }
+      end
 
-      def collection
-        if @options.key?(:collection)
-          collection = @options[:collection]
-          collection.respond_to?(:to_ary) ? collection.to_ary : []
-        end
+      self
+    end
+
+    def collection
+      if @options.key?(:collection)
+        collection = @options[:collection]
+        collection.respond_to?(:to_ary) ? collection.to_ary : []
       end
+    end
 
-      def collection_from_object
-        if @object.respond_to?(:to_ary)
-          @object.to_ary
-        end
+    def collection_from_object
+      if @object.respond_to?(:to_ary)
+        @object.to_ary
       end
+    end
 
-      def find_template(path=@path)
-        return path unless path.is_a?(String)
-        prefix = @view.controller_path unless path.include?(?/)
-        @view.find_template(path, prefix, true)
+    def find_partial
+      if path = @path
+        locals = @locals.keys
+        locals << @variable
+        locals << @variable_counter if @collection
+        find_template(path, locals)
       end
+    end
 
-      def partial_path(object = @object)
-        @partial_names[object.class.name] ||= begin
-          object = object.to_model if object.respond_to?(:to_model)
+    def find_template(path=@path, locals=@locals.keys)
+      prefixes = path.include?(?/) ? [] : @lookup_context.prefixes
+      @lookup_context.find_template(path, prefixes, true, locals)
+    end
 
-          object.class.model_name.partial_path.dup.tap do |partial|
-            path = @view.controller_path
-            partial.insert(0, "#{File.dirname(path)}/") if partial.include?(?/) && path.include?(?/)
-          end
-        end
+    def collection_with_template
+      segments, locals, template = [], @locals, @template
+      as, counter = @variable, @variable_counter
+
+      locals[counter] = -1
+
+      @collection.each do |object|
+        locals[counter] += 1
+        locals[as] = object
+        segments << template.render(@view, locals)
       end
+
+      segments
     end
 
-    def _render_partial(options, &block) #:nodoc:
-      if defined?(@renderer)
-        @renderer.setup(options, block)
-      else
-        @renderer = PartialRenderer.new(self, options, block)
+    def collection_without_template
+      segments, locals, collection_data = [], @locals, @collection_data
+      index, template, cache = -1, nil, {}
+      keys = @locals.keys
+
+      @collection.each_with_index do |object, i|
+        path, *data = collection_data[i]
+        template = (cache[path] ||= find_template(path, keys + data))
+        locals[data[0]] = object
+        locals[data[1]] = (index += 1)
+        segments << template.render(@view, locals)
       end
 
-      @renderer.render
+      @template = template
+      segments
     end
 
+    def partial_path(object = @object)
+      @partial_names[object.class.name] ||= begin
+        object = object.to_model if object.respond_to?(:to_model)
+
+        object.class.model_name.partial_path.dup.tap do |partial|
+          path = @lookup_context.prefixes.first
+          partial.insert(0, "#{File.dirname(path)}/") if partial.include?(?/) && path.include?(?/)
+        end
+      end
+    end
+
+    def retrieve_variable(path)
+      variable = @options[:as].try(:to_sym) || path[%r'_?(\w+)(\.\w+)*$', 1].to_sym
+      variable_counter = :"#{variable}_counter" if @collection
+      [variable, variable_counter]
+    end
   end
 end