actionpack 3.0.0.beta → 3.0.0.beta2

data/lib/action_view/lookup_context.rb

@@ -0,0 +1,190 @@
+require 'active_support/core_ext/array/wrap'
+require 'active_support/core_ext/object/blank'
+
+module ActionView
+  # LookupContext is the object responsible to hold all information required to lookup
+  # templates, i.e. view paths and details. The LookupContext is also responsible to
+  # 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:
+    mattr_accessor :fallbacks
+    @@fallbacks = [FileSystemResolver.new(""), FileSystemResolver.new("/")]
+
+    mattr_accessor :registered_details
+    self.registered_details = []
+
+    def self.register_detail(name, options = {}, &block)
+      self.registered_details << name
+      Accessors.send :define_method, :"_#{name}_defaults", &block
+      Accessors.module_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{name}
+          @details[:#{name}]
+        end
+
+        def #{name}=(value)
+          value = Array.wrap(value.presence || _#{name}_defaults)
+
+          if value != @details[:#{name}]
+            @details_key = nil
+            @details = @details.dup if @details.frozen?
+            @details[:#{name}] = value.freeze
+          end
+        end
+      METHOD
+    end
+
+    # Holds accessors for the registered details.
+    module Accessors #:nodoc:
+    end
+
+    register_detail(:formats) { Mime::SET.symbols }
+    register_detail(:locale)  { [I18n.locale] }
+
+    class DetailsKey #:nodoc:
+      alias :eql? :equal?
+      alias :object_hash :hash
+
+      attr_reader :hash
+      @details_keys = Hash.new
+
+      def self.get(details)
+        @details_keys[details.freeze] ||= new
+      end
+
+      def initialize
+        @hash = object_hash
+      end
+    end
+
+    def initialize(view_paths, details = {})
+      @details, @details_key = { :handlers => default_handlers }, nil
+      @frozen_formats = false
+      self.view_paths = view_paths
+      self.update_details(details, true)
+    end
+
+    module ViewPaths
+      attr_reader :view_paths
+
+      # Whenever setting view paths, makes a copy so we can manipulate then in
+      # instance objects as we wish.
+      def view_paths=(paths)
+        @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))
+      end
+      alias :find_template :find
+
+      def find_all(name, prefix = nil, partial = false)
+        @view_paths.find_all(*args_for_lookup(name, prefix, partial))
+      end
+
+      def exists?(name, prefix = nil, partial = false)
+        @view_paths.exists?(*args_for_lookup(name, prefix, partial))
+      end
+      alias :template_exists? :exists?
+
+      # Add fallbacks to the view paths. Useful in cases you are rendering a :file.
+      def with_fallbacks
+        added_resolvers = 0
+        self.class.fallbacks.each do |resolver|
+          next if view_paths.include?(resolver)
+          view_paths.push(resolver)
+          added_resolvers += 1
+        end
+        yield
+      ensure
+        added_resolvers.times { view_paths.pop }
+      end
+
+    protected
+
+      def args_for_lookup(name, prefix, partial) #:nodoc:
+        name, prefix = normalize_name(name, prefix)
+        [name, prefix, partial || false, @details, details_key]
+      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:
+        name  = name.to_s.gsub(handlers_regexp, '')
+        parts = name.split('/')
+        return parts.pop, [prefix, *parts].compact.join("/")
+      end
+
+      def default_handlers #:nodoc:
+        @default_handlers ||= Template::Handlers.extensions
+      end
+
+      def handlers_regexp #:nodoc:
+        @handlers_regexp ||= /\.(?:#{default_handlers.join('|')})$/
+      end
+    end
+
+    module Details
+      # 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)
+      end
+
+      # Freeze the current formats in the lookup context. By freezing them, you are guaranteeing
+      # that next template lookups are not going to modify the formats. The controller can also
+      # use this, to ensure that formats won't be further modified (as it does in respond_to blocks).
+      def freeze_formats(formats, unless_frozen=false) #:nodoc:
+        return if unless_frozen && @frozen_formats
+        self.formats = formats
+        @frozen_formats = true
+      end
+
+      # Overload formats= to reject [:"*/*"] values.
+      def formats=(value)
+        value = nil    if value == [:"*/*"]
+        value << :html if value == [:js]
+        super(value)
+      end
+
+      # Overload locale to return a symbol instead of array
+      def locale
+        @details[:locale].first
+      end
+
+      # Overload locale= to also set the I18n.locale. If the current I18n.config object responds
+      # to i18n_config, it means that it's has a copy of the original I18n configuration and it's
+      # acting as proxy, which we need to skip.
+      def locale=(value)
+        if value
+          config = I18n.config.respond_to?(:i18n_config) ? I18n.config.i18n_config : I18n.config
+          config.locale = value
+        end
+        super(I18n.locale)
+      end
+
+      # Update the details keys by merging the given hash into the current
+      # details hash. If a block is given, the details are modified just during
+      # the execution of the block and reverted to the previous value after.
+      def update_details(new_details, force=false)
+        old_details = @details.dup
+
+        registered_details.each do |key|
+          send(:"#{key}=", new_details[key]) if force || new_details.key?(key)
+        end
+
+        if block_given?
+          begin
+            yield
+          ensure
+            @details = old_details
+          end
+        end
+      end
+    end
+
+    include Accessors
+    include Details
+    include ViewPaths
+  end
+end

data/lib/action_view/paths.rb

@@ -1,80 +1,39 @@
 module ActionView #:nodoc:
   class PathSet < Array #:nodoc:
-    def self.type_cast(obj, cache = nil)
-      # TODO: Clean this up
-      if obj.is_a?(String)
-        if cache.nil?
-          cache = !defined?(Rails.application) || Rails.application.config.cache_classes
+    %w(initialize << concat insert push unshift).each do |method|
+      class_eval <<-METHOD, __FILE__, __LINE__ + 1
+        def #{method}(*args)
+          super
+          typecast!
         end
-        FileSystemResolverWithFallback.new(obj, :cache => cache)
-      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) })
+      METHOD
     end
 
-    def unshift(*objs)
-      super(*objs.map { |obj| self.class.type_cast(obj) })
+    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
     end
 
-    def find(path, details = {}, prefix = nil, partial = false)
-      template_path = path
-
-      each do |load_path|
-        if template = load_path.find(template_path, details, prefix, partial)
-          return template
-        end
+    def find_all(*args)
+      each do |resolver|
+        templates = resolver.find_all(*args)
+        return templates unless templates.empty?
       end
-      
-      raise ActionView::MissingTemplate.new(self, "#{prefix}/#{path}", details, partial)
+      []
     end
-    
-    def exists?(path, extension = nil, prefix = nil, partial = false)
-      template_path = path.sub(/^\//, '')
 
-      each do |load_path|
-        return true if template = load_path.find(template_path, extension, prefix, partial)
-      end      
-      false
+    def exists?(*args)
+      find_all(*args).any?
     end
 
-    def find_template(original_template_path, format = nil, html_fallback = true)
-      return original_template_path if original_template_path.respond_to?(:render)
-      template_path = original_template_path.sub(/^\//, '')
+  protected
 
-      each do |load_path|
-        if template = load_path.find(template_path, format)
-          return template
-        # Try to find html version if the format is javascript
-        elsif format == :js && html_fallback && template = load_path["#{template_path}.#{I18n.locale}.html"]
-          return template
-        elsif format == :js && html_fallback && template = load_path["#{template_path}.html"]
-          return template
-        end
+    def typecast!
+      each_with_index do |path, i|
+        next unless path.is_a?(String)
+        self[i] = FileSystemResolver.new(path)
       end
-
-      return Template.new(original_template_path, original_template_path.to_s =~ /\A\// ? "" : ".") if File.file?(original_template_path)
-
-      raise MissingTemplate.new(self, original_template_path, format)
     end
   end
 end

data/lib/action_view/railtie.rb

@@ -3,14 +3,24 @@ require "rails"
 
 module ActionView
   class Railtie < Rails::Railtie
-    railtie_name :action_view
+    config.action_view = ActiveSupport::OrderedOptions.new
 
-    require "action_view/railties/subscriber"
-    subscriber ActionView::Railties::Subscriber.new
+    require "action_view/railties/log_subscriber"
+    log_subscriber :action_view, ActionView::Railties::LogSubscriber.new
 
     initializer "action_view.cache_asset_timestamps" do |app|
       unless app.config.cache_classes
-        ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
+        ActiveSupport.on_load(:action_view) do
+          ActionView::Helpers::AssetTagHelper.cache_asset_timestamps = false
+        end
+      end
+    end
+
+    initializer "action_view.set_configs" do |app|
+      ActiveSupport.on_load(:action_view) do
+        app.config.action_view.each do |k,v|
+          send "#{k}=", v
+        end
       end
     end
   end

data/lib/action_view/railties/{subscriber.rb → log_subscriber.rb}

@@ -1,6 +1,6 @@
 module ActionView
   module Railties
-    class Subscriber < Rails::Subscriber
+    class LogSubscriber < Rails::LogSubscriber
       def render_template(event)
         message = "Rendered #{from_rails_root(event.payload[:identifier])}"
         message << " within #{from_rails_root(event.payload[:layout])}" if event.payload[:layout]

data/lib/action_view/render/layouts.rb

@@ -0,0 +1,73 @@
+module ActionView
+  module Layouts
+    # You can think of a layout as a method that is called with a block. _layout_for
+    # returns the contents that are yielded to the layout. If the user calls yield
+    # :some_name, the block, by default, returns content_for(:some_name). If the user
+    # calls yield, the default block returns content_for(:layout).
+    #
+    # The user can override this default by passing a block to the layout.
+    #
+    # ==== Example
+    #
+    #   # The template
+    #   <%= render :layout => "my_layout" do %>Content<% end %>
+    #
+    #   # The layout
+    #   <html><% yield %></html>
+    #
+    # In this case, instead of the default block, which would return content_for(:layout),
+    # this method returns the block that was passed in to render layout, and the response
+    # would be <html>Content</html>.
+    #
+    # Finally, the block can take block arguments, which can be passed in by yield.
+    #
+    # ==== Example
+    #
+    #   # The template
+    #   <%= render :layout => "my_layout" do |customer| %>Hello <%= customer.name %><% end %>
+    #
+    #   # The layout
+    #   <html><% yield Struct.new(:name).new("David") %></html>
+    #
+    # In this case, the layout would receive the block passed into <tt>render :layout</tt>,
+    # and the Struct specified in the layout would be passed into the block. The result
+    # would be <html>Hello David</html>.
+    def _layout_for(name = nil, &block) #:nodoc:
+      if !block || name
+        @_content_for[name || :layout]
+      else
+        capture(&block)
+      end
+    end
+
+    # This is the method which actually finds the layout using details in the lookup
+    # context object. If no layout is found, it checkes if at least a layout with
+    # the given name exists across all details before raising the error.
+    #
+    # If self.formats contains several formats, just the first one is considered in
+    # the layout lookup.
+    def find_layout(layout)
+      begin
+        if formats.size == 1
+          _find_layout(layout)
+        else
+          update_details(:formats => self.formats.first){ _find_layout(layout) }
+        end
+      rescue ActionView::MissingTemplate => e
+        update_details(:formats => nil) do
+          raise unless template_exists?(layout)
+        end
+      end
+    end
+
+    def _find_layout(layout) #:nodoc:
+      layout =~ /^\// ?
+        with_fallbacks { find_template(layout) } : find_template(layout)
+    end
+
+    # Contains the logic that actually renders the layout.
+    def _render_layout(layout, locals, &block) #:nodoc:
+      layout.render(self, locals){ |*name| _layout_for(*name, &block) }
+    end
+  end
+end

data/lib/action_view/render/partials.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/object/blank'
+
 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
@@ -123,7 +125,7 @@ module ActionView
   # You can also apply a layout to a block within any template:
   #
   #   <%# app/views/users/_chief.html.erb &>
-  #   <% render(:layout => "administrator", :locals => { :user => chief }) do %>
+  #   <%= render(:layout => "administrator", :locals => { :user => chief }) do %>
   #     Title: <%= chief.title %>
   #   <% end %>
   #
@@ -146,7 +148,7 @@ module ActionView
   #   </div>
   #
   #   <%# app/views/users/index.html.erb &>
-  #   <% render :layout => @users do |user| %>
+  #   <%= render :layout => @users do |user| %>
   #     Title: <%= user.title %>
   #   <% end %>
   #
@@ -162,7 +164,7 @@ module ActionView
   #   </div>
   #
   #   <%# app/views/users/index.html.erb &>
-  #   <% render :layout => @users do |user, section| %>
+  #   <%= render :layout => @users do |user, section| %>
   #     <%- case section when :header -%>
   #       Title: <%= user.title %>
   #     <%- when :footer -%>
@@ -174,17 +176,11 @@ module ActionView
 
     class PartialRenderer
       PARTIAL_NAMES = Hash.new {|h,k| h[k] = {} }
-      TEMPLATES = Hash.new {|h,k| h[k] = {} }
-
-      attr_reader :template
 
       def initialize(view_context, options, block)
         @view           = view_context
         @partial_names  = PARTIAL_NAMES[@view.controller.class]
 
-        key = Thread.current[:format_locale_key]
-        @templates      = TEMPLATES[key] if key
-
         setup(options, block)
       end
 
@@ -228,6 +224,7 @@ module ActionView
           if !@block && (layout = @options[:layout])
             content = @view._render_layout(find_template(layout), @locals){ content }
           end
+
           content
         end
       end
@@ -244,9 +241,9 @@ module ActionView
       end
 
       def collection_with_template(template = @template)
-        segments, locals, as = [], @locals, @options[:as] || template.variable_name
+        segments, locals, as, template = [], @locals, @options[:as] || @template.variable_name, @template
 
-        counter_name  = template.counter_name
+        counter_name = template.counter_name
         locals[counter_name] = -1
 
         @collection.each do |object|
@@ -256,7 +253,6 @@ module ActionView
           segments << template.render(@view, locals)
         end
 
-        @template = template
         segments
       end
 
@@ -277,7 +273,7 @@ module ActionView
       end
 
       def render_partial(object = @object)
-        locals, view = @locals, @view
+        locals, view, template = @locals, @view, @template
 
         object ||= locals[template.variable_name]
         locals[@options[:as] || template.variable_name] = object
@@ -288,6 +284,7 @@ module ActionView
       end
 
     private
+
       def collection
         if @object.respond_to?(:to_ary)
           @object
@@ -296,20 +293,10 @@ module ActionView
         end
       end
 
-      def find_template(path = @path)
-        unless @templates
-          path && _find_template(path)
-        else
-          path && @templates[path] ||= _find_template(path)
-        end
-      end
-
-      def _find_template(path)
-        if controller = @view.controller
-          prefix = controller.controller_path unless path.include?(?/)
-        end
-
-        @view.find(path, {:formats => @view.formats}, prefix, true)
+      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)
       end
 
       def partial_path(object = @object)
@@ -324,21 +311,8 @@ module ActionView
       end
     end
 
-    def render_partial(options)
-      _evaluate_assigns_and_ivars
-
-      details = options[:_details]
-
-      # Is this needed
-      self.formats = details[:formats] if details
-      renderer = PartialRenderer.new(self, options, nil)
-      text = renderer.render
-      options[:_template] = renderer.template
-      text
-    end
-
     def _render_partial(options, &block) #:nodoc:
-      if defined? @renderer
+      if defined?(@renderer)
         @renderer.setup(options, block)
       else
         @renderer = PartialRenderer.new(self, options, block)