actionpack 2.1.2 → 2.2.2

data/lib/action_view/partials.rb

@@ -1,14 +1,15 @@
 module ActionView
-  # There's also a convenience method for rendering sub templates within the current controller that depends on a single object
-  # (we call this kind of sub templates for partials). It relies on the fact that partials should follow the naming convention of being
-  # prefixed with an underscore -- as to separate them from regular templates that could be rendered on their own.
+  # There's also a convenience method for rendering sub templates within the current controller that depends on a
+  # single object (we call this kind of sub templates for partials). It relies on the fact that partials should
+  # follow the naming convention of being prefixed with an underscore -- as to separate them from regular
+  # templates that could be rendered on their own.
   #
   # In a template for Advertiser#account:
   #
   #  <%= render :partial => "account" %>
   #
-  # This would render "advertiser/_account.erb" and pass the instance variable @account in as a local variable +account+ to
-  # the template for display.
+  # This would render "advertiser/_account.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:
   #
@@ -18,24 +19,24 @@ module ActionView
   #     <%= 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.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.
   #
   # == Rendering a collection of partials
   #
-  # The example of partial use describes a familiar pattern where a template needs to iterate over an array and render a sub
-  # template for each of the elements. This pattern has been implemented as a single method that accepts an array and renders
-  # a partial by the same name as the elements contained within. So the three-lined example in "Using partials" can be rewritten
-  # with a single line:
+  # The example of partial use describes a familiar pattern where a template needs to iterate over an array and
+  # render a sub template for each of the elements. This pattern has been implemented as a single method that
+  # accepts an array and renders a partial by the same name as the elements contained within. So the three-lined
+  # example in "Using partials" can be rewritten with a single line:
   #
   #   <%= render :partial => "ad", :collection => @advertisements %>
   #
-  # This will render "advertiser/_ad.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+.
+  # This will render "advertiser/_ad.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+.
   #
-  # 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.
+  # 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.
   #
   # == Rendering shared partials
   #
@@ -47,8 +48,9 @@ module ActionView
   #
   # == Rendering partials with layouts
   #
-  # Partials can have their own layouts applied to them. These layouts are different than the ones that are specified globally
-  # for the entire action, but they work in a similar fashion. Imagine a list with two types of users:
+  # Partials can have their own layouts applied to them. These layouts are different than the ones that are
+  # specified globally for the entire action, but they work in a similar fashion. Imagine a list with two types
+  # of users:
   #
   #   <%# app/views/users/index.html.erb &>
   #   Here's the administrator:
@@ -68,7 +70,7 @@ module ActionView
   #
   #   <%# app/views/users/_editor.html.erb &>
   #   <div id="editor">
-  #     Deadline: $<%= user.deadline %>
+  #     Deadline: <%= user.deadline %>
   #     <%= yield %>
   #   </div>
   #
@@ -82,7 +84,7 @@ module ActionView
   #
   #   Here's the editor:
   #   <div id="editor">
-  #     Deadline: $<%= user.deadline %>
+  #     Deadline: <%= user.deadline %>
   #     Name: <%= user.name %>
   #   </div>
   #
@@ -101,58 +103,101 @@ module ActionView
   #   </div>
   #
   # As you can see, the <tt>:locals</tt> hash is shared between both the partial and its layout.
+  #
+  # If you pass arguments to "yield" then this will be passed to the block. One way to use this is to pass
+  # an array to layout and treat it as an enumerable.
+  #
+  #   <%# app/views/users/_user.html.erb &>
+  #   <div class="user">
+  #     Budget: $<%= user.budget %>
+  #     <%= yield user %>
+  #   </div>
+  #
+  #   <%# app/views/users/index.html.erb &>
+  #   <% render :layout => @users do |user| %>
+  #     Title: <%= user.title %>
+  #   <% end %>
+  #
+  # This will render the layout for each user and yield to the block, passing the user, each time.
+  #
+  # You can also yield multiple times in one layout and use block arguments to differentiate the sections.
+  #
+  #   <%# app/views/users/_user.html.erb &>
+  #   <div class="user">
+  #     <%= yield user, :header %>
+  #     Budget: $<%= user.budget %>
+  #     <%= yield user, :footer %>
+  #   </div>
+  #
+  #   <%# app/views/users/index.html.erb &>
+  #   <% render :layout => @users do |user, section| %>
+  #     <%- case section when :header -%>
+  #       Title: <%= user.title %>
+  #     <%- when :footer -%>
+  #       Deadline: <%= user.deadline %>
+  #     <%- end -%>
+  #   <% end %>
   module Partials
+    extend ActiveSupport::Memoizable
+
     private
-      def render_partial(partial_path, object_assigns = nil, local_assigns = {}) #:nodoc:
-        case partial_path
+      def render_partial(options = {}) #:nodoc:
+        local_assigns = options[:locals] || {}
+
+        case partial_path = options[:partial]
         when String, Symbol, NilClass
-          # Render the template
-          ActionView::PartialTemplate.new(self, partial_path, object_assigns, local_assigns).render_template
+          if options.has_key?(:collection)
+            render_partial_collection(options)
+          else
+            _pick_partial_template(partial_path).render_partial(self, options[:object], local_assigns)
+          end
         when ActionView::Helpers::FormBuilder
           builder_partial_path = partial_path.class.to_s.demodulize.underscore.sub(/_builder$/, '')
-          render_partial(builder_partial_path, object_assigns, (local_assigns || {}).merge(builder_partial_path.to_sym => partial_path))
+          local_assigns.merge!(builder_partial_path.to_sym => partial_path)
+          render_partial(:partial => builder_partial_path, :object => options[:object], :locals => local_assigns)
         when Array, ActiveRecord::Associations::AssociationCollection, ActiveRecord::NamedScope::Scope
-          if partial_path.any?
-            collection = partial_path
-            render_partial_collection(nil, collection, nil, local_assigns)
-          else
-            ""
-          end
+          render_partial_collection(options.except(:partial).merge(:collection => partial_path))
         else
-          render_partial(ActionController::RecordIdentifier.partial_path(partial_path, controller.class.controller_path), partial_path, local_assigns)
+          object = partial_path
+          render_partial(
+            :partial => ActionController::RecordIdentifier.partial_path(object, controller.class.controller_path),
+            :object => object,
+            :locals => local_assigns
+          )
         end
       end
 
-      def render_partial_collection(partial_path, collection, partial_spacer_template = nil, local_assigns = {}) #:nodoc:
-        return " " if collection.empty?
+      def render_partial_collection(options = {}) #:nodoc:
+        return nil if options[:collection].blank?
 
-        local_assigns = local_assigns ? local_assigns.clone : {}
-        spacer = partial_spacer_template ? render(:partial => partial_spacer_template) : ''
+        partial = options[:partial]
+        spacer = options[:spacer_template] ? render(:partial => options[:spacer_template]) : ''
+        local_assigns = options[:locals] ? options[:locals].clone : {}
+        as = options[:as]
 
-        if partial_path.nil?
-          render_partial_collection_with_unknown_partial_path(collection, local_assigns)
-        else
-          render_partial_collection_with_known_partial_path(collection, partial_path, local_assigns)
+        index = 0
+        options[:collection].map do |object|
+          _partial_path ||= partial ||
+            ActionController::RecordIdentifier.partial_path(object, controller.class.controller_path)
+          template = _pick_partial_template(_partial_path)
+          local_assigns[template.counter_name] = index
+          result = template.render_partial(self, object, local_assigns.dup, as)
+          index += 1
+          result
         end.join(spacer)
       end
 
-      def render_partial_collection_with_known_partial_path(collection, partial_path, local_assigns)
-        template = ActionView::PartialTemplate.new(self, partial_path, nil, local_assigns)
-        collection.map do |element|
-          template.render_member(element)
+      def _pick_partial_template(partial_path) #:nodoc:
+        if partial_path.include?('/')
+          path = File.join(File.dirname(partial_path), "_#{File.basename(partial_path)}")
+        elsif controller
+          path = "#{controller.class.controller_path}/_#{partial_path}"
+        else
+          path = "_#{partial_path}"
         end
-      end
 
-      def render_partial_collection_with_unknown_partial_path(collection, local_assigns)
-        templates = Hash.new
-        i = 0
-        collection.map do |element|
-          partial_path = ActionController::RecordIdentifier.partial_path(element, controller.class.controller_path)
-          template = templates[partial_path] ||= ActionView::PartialTemplate.new(self, partial_path, nil, local_assigns)
-          template.counter = i
-          i += 1
-          template.render_member(element)
-        end
+        _pick_template(path)
       end
+      memoize :_pick_partial_template
   end
 end

data/lib/action_view/paths.rb

@@ -0,0 +1,125 @@
+module ActionView #:nodoc:
+  class PathSet < Array #:nodoc:
+    def self.type_cast(obj)
+      if obj.is_a?(String)
+        if Base.warn_cache_misses && defined?(Rails) && Rails.initialized?
+          Base.logger.debug "[PERFORMANCE] Processing view path during a " +
+            "request. This an expense disk operation that should be done at " +
+            "boot. You can manually process this view path with " +
+            "ActionView::Base.process_view_paths(#{obj.inspect}) and set it " +
+            "as your view path"
+        end
+        Path.new(obj)
+      else
+        obj
+      end
+    end
+
+    def initialize(*args)
+      super(*args).map! { |obj| self.class.type_cast(obj) }
+    end
+
+    def <<(obj)
+      super(self.class.type_cast(obj))
+    end
+
+    def concat(array)
+      super(array.map! { |obj| self.class.type_cast(obj) })
+    end
+
+    def insert(index, obj)
+      super(index, self.class.type_cast(obj))
+    end
+
+    def push(*objs)
+      super(*objs.map { |obj| self.class.type_cast(obj) })
+    end
+
+    def unshift(*objs)
+      super(*objs.map { |obj| self.class.type_cast(obj) })
+    end
+
+    class Path #:nodoc:
+      def self.eager_load_templates!
+        @eager_load_templates = true
+      end
+
+      def self.eager_load_templates?
+        @eager_load_templates || false
+      end
+
+      attr_reader :path, :paths
+      delegate :to_s, :to_str, :hash, :inspect, :to => :path
+
+      def initialize(path, load = true)
+        raise ArgumentError, "path already is a Path class" if path.is_a?(Path)
+        @path = path.freeze
+        reload! if load
+      end
+
+      def ==(path)
+        to_str == path.to_str
+      end
+
+      def eql?(path)
+        to_str == path.to_str
+      end
+
+      def [](path)
+        raise "Unloaded view path! #{@path}" unless @loaded
+        @paths[path]
+      end
+
+      def loaded?
+        @loaded ? true : false
+      end
+
+      def load
+        reload! unless loaded?
+        self
+      end
+
+      # Rebuild load path directory cache
+      def reload!
+        @paths = {}
+
+        templates_in_path do |template|
+          # Eager load memoized methods and freeze cached template
+          template.freeze if self.class.eager_load_templates?
+
+          @paths[template.path] = template
+          @paths[template.path_without_extension] ||= template
+        end
+
+        @paths.freeze
+        @loaded = true
+      end
+
+      private
+        def templates_in_path
+          (Dir.glob("#{@path}/**/*/**") | Dir.glob("#{@path}/**")).each do |file|
+            unless File.directory?(file)
+              yield Template.new(file.split("#{self}/").last, self)
+            end
+          end
+        end
+    end
+
+    def load
+      each { |path| path.load }
+    end
+
+    def reload!
+      each { |path| path.reload! }
+    end
+
+    def [](template_path)
+      each do |path|
+        if template = path[template_path]
+          return template
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/action_view/renderable.rb

@@ -0,0 +1,102 @@
+module ActionView
+  # NOTE: The template that this mixin is being included into is frozen
+  # so you cannot set or modify any instance variables
+  module Renderable #:nodoc:
+    extend ActiveSupport::Memoizable
+
+    def self.included(base)
+      @@mutex = Mutex.new
+    end
+
+    def filename
+      'compiled-template'
+    end
+
+    def handler
+      Template.handler_class_for_extension(extension)
+    end
+    memoize :handler
+
+    def compiled_source
+      handler.call(self)
+    end
+    memoize :compiled_source
+
+    def render(view, local_assigns = {})
+      compile(local_assigns)
+
+      stack = view.instance_variable_get(:@_render_stack)
+      stack.push(self)
+
+      # This is only used for TestResponse to set rendered_template
+      unless is_a?(InlineTemplate) || view.instance_variable_get(:@_first_render)
+        view.instance_variable_set(:@_first_render, self)
+      end
+
+      view.send(:_evaluate_assigns_and_ivars)
+      view.send(:_set_controller_content_type, mime_type) if respond_to?(:mime_type)
+
+      result = view.send(method_name(local_assigns), local_assigns) do |*names|
+        ivar = :@_proc_for_layout
+        if !view.instance_variable_defined?(:"@content_for_#{names.first}") && view.instance_variable_defined?(ivar) && (proc = view.instance_variable_get(ivar))
+          view.capture(*names, &proc)
+        elsif view.instance_variable_defined?(ivar = :"@content_for_#{names.first || :layout}")
+          view.instance_variable_get(ivar)
+        end
+      end
+
+      stack.pop
+      result
+    end
+
+    def method_name(local_assigns)
+      if local_assigns && local_assigns.any?
+        local_assigns_keys = "locals_#{local_assigns.keys.map { |k| k.to_s }.sort.join('_')}"
+      end
+      ['_run', extension, method_segment, local_assigns_keys].compact.join('_').to_sym
+    end
+
+    private
+      # Compile and evaluate the template's code (if necessary)
+      def compile(local_assigns)
+        render_symbol = method_name(local_assigns)
+
+        @@mutex.synchronize do
+          if recompile?(render_symbol)
+            compile!(render_symbol, local_assigns)
+          end
+        end
+      end
+
+      def compile!(render_symbol, local_assigns)
+        locals_code = local_assigns.keys.map { |key| "#{key} = local_assigns[:#{key}];" }.join
+
+        source = <<-end_src
+          def #{render_symbol}(local_assigns)
+            old_output_buffer = output_buffer;#{locals_code};#{compiled_source}
+          ensure
+            self.output_buffer = old_output_buffer
+          end
+        end_src
+
+        begin
+          ActionView::Base::CompiledTemplates.module_eval(source, filename, 0)
+        rescue Exception => e # errors from template code
+          if logger = defined?(ActionController) && Base.logger
+            logger.debug "ERROR: compiling #{render_symbol} RAISED #{e}"
+            logger.debug "Function body: #{source}"
+            logger.debug "Backtrace: #{e.backtrace.join("\n")}"
+          end
+
+          raise ActionView::TemplateError.new(self, {}, e)
+        end
+      end
+
+      # Method to check whether template compilation is necessary.
+      # The template will be compiled if the file has not been compiled yet, or
+      # if local_assigns has a new key, which isn't supported by the compiled code yet.
+      def recompile?(symbol)
+        !(ActionView::PathSet::Path.eager_load_templates? && Base::CompiledTemplates.method_defined?(symbol))
+      end
+  end
+end

data/lib/action_view/renderable_partial.rb

@@ -0,0 +1,48 @@
+module ActionView
+  # NOTE: The template that this mixin is being included into is frozen
+  # so you cannot set or modify any instance variables
+  module RenderablePartial #:nodoc:
+    extend ActiveSupport::Memoizable
+
+    def variable_name
+      name.sub(/\A_/, '').to_sym
+    end
+    memoize :variable_name
+
+    def counter_name
+      "#{variable_name}_counter".to_sym
+    end
+    memoize :counter_name
+
+    def render(view, local_assigns = {})
+      if defined? ActionController
+        ActionController::Base.benchmark("Rendered #{path_without_format_and_extension}", Logger::DEBUG, false) do
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def render_partial(view, object = nil, local_assigns = {}, as = nil)
+      object ||= local_assigns[:object] ||
+        local_assigns[variable_name]
+
+      if view.respond_to?(:controller)
+        ivar = :"@#{variable_name}"
+        object ||=
+          if view.controller.instance_variable_defined?(ivar)
+            ActiveSupport::Deprecation::DeprecatedObjectProxy.new(
+              view.controller.instance_variable_get(ivar),
+              "#{ivar} will no longer be implicitly assigned to #{variable_name}")
+          end
+      end
+
+      # Ensure correct object is reassigned to other accessors
+      local_assigns[:object] = local_assigns[variable_name] = object
+      local_assigns[as] = object if as
+
+      render_template(view, local_assigns)
+    end
+  end
+end