actionpack 1.13.6 → 2.0.0

data/lib/action_controller/layout.rb

@@ -64,13 +64,13 @@ module ActionController #:nodoc:
     #
     # If there is a template in <tt>app/views/layouts/</tt> with the same name as the current controller then it will be automatically
     # set as that controller's layout unless explicitly told otherwise. Say you have a WeblogController, for example. If a template named 
-    # <tt>app/views/layouts/weblog.rhtml</tt> or <tt>app/views/layouts/weblog.rxml</tt> exists then it will be automatically set as
-    # the layout for your WeblogController. You can create a layout with the name <tt>application.rhtml</tt> or <tt>application.rxml</tt>
+    # <tt>app/views/layouts/weblog.erb</tt> or <tt>app/views/layouts/weblog.builder</tt> exists then it will be automatically set as
+    # the layout for your WeblogController. You can create a layout with the name <tt>application.erb</tt> or <tt>application.builder</tt>
     # and this will be set as the default controller if there is no layout with the same name as the current controller and there is 
     # no layout explicitly assigned with the +layout+ method. Nested controllers use the same folder structure for automatic layout.
-    # assignment. So an Admin::WeblogController will look for a template named <tt>app/views/layouts/admin/weblog.rhtml</tt>.
+    # assignment. So an Admin::WeblogController will look for a template named <tt>app/views/layouts/admin/weblog.erb</tt>.
     # Setting a layout explicitly will always override the automatic behaviour for the controller where the layout is set.
-    # Explicitly setting the layout in a parent class, though, will not override the child class's layout assignement if the child
+    # Explicitly setting the layout in a parent class, though, will not override the child class's layout assignment if the child
     # class has a layout with the same name. 
     #
     # == Inheritance for layouts
@@ -165,30 +165,39 @@ module ActionController #:nodoc:
     # variable. The preferred notation now is to use <tt>yield</tt>, as documented above.
     module ClassMethods
       # If a layout is specified, all rendered actions will have their result rendered  
-      # when the layout<tt>yield</tt>'s. This layout can itself depend on instance variables assigned during action
+      # when the layout <tt>yield</tt>s. This layout can itself depend on instance variables assigned during action
       # performance and have access to them as any normal template would.
-      def layout(template_name, conditions = {})
+      def layout(template_name, conditions = {}, auto = false)
         add_layout_conditions(conditions)
         write_inheritable_attribute "layout", template_name
+        write_inheritable_attribute "auto_layout", auto
       end
 
       def layout_conditions #:nodoc:
         @layout_conditions ||= read_inheritable_attribute("layout_conditions")
       end
       
-      def default_layout #:nodoc:
-        @default_layout ||= read_inheritable_attribute("layout")
+      def default_layout(format) #:nodoc:
+        layout = read_inheritable_attribute("layout")                 
+        return layout unless read_inheritable_attribute("auto_layout")
+        @default_layout ||= {}
+        @default_layout[format] ||= default_layout_with_format(format, layout)
+        @default_layout[format]
       end
-
+      
+      def layout_list #:nodoc:
+        view_paths.collect do |path|
+          Dir["#{path}/layouts/**/*"]
+        end.flatten
+      end
+      
       private
         def inherited_with_layout(child)
           inherited_without_layout(child)
-          layout_match = child.name.underscore.sub(/_controller$/, '').sub(/^controllers\//, '')
-          child.layout(layout_match) unless layout_list.grep(%r{layouts/#{layout_match}\.[a-z][0-9a-z]*$}).empty?
-        end
-
-        def layout_list
-          Dir.glob("#{template_root}/layouts/**/*")
+          unless child.name.blank?
+            layout_match = child.name.underscore.sub(/_controller$/, '').sub(/^controllers\//, '')
+            child.layout(layout_match, {}, true) unless child.layout_list.grep(%r{layouts/#{layout_match}(\.[a-z][0-9a-z]*)+$}).empty?
+          end
         end
 
         def add_layout_conditions(conditions)
@@ -204,6 +213,15 @@ module ActionController #:nodoc:
             h[dirname] = File.directory? dirname
           end
         end
+        
+        def default_layout_with_format(format, layout)
+          list = layout_list
+          if list.grep(%r{layouts/#{layout}\.#{format}(\.[a-z][0-9a-z]*)+$}).empty?
+            (!list.grep(%r{layouts/#{layout}\.([a-z][0-9a-z]*)+$}).empty? && format == :html) ? layout : nil
+          else
+            layout
+          end
+        end
     end
 
     # Returns the name of the active layout. If the layout was specified as a method reference (through a symbol), this method
@@ -211,11 +229,10 @@ module ActionController #:nodoc:
     # object). If the layout was defined without a directory, layouts is assumed. So <tt>layout "weblog/standard"</tt> will return
     # weblog/standard, but <tt>layout "standard"</tt> will return layouts/standard.
     def active_layout(passed_layout = nil)
-      layout = passed_layout || self.class.default_layout
-
+      layout = passed_layout || self.class.default_layout(response.template.template_format)
       active_layout = case layout
         when String then layout
-        when Symbol then send(layout)
+        when Symbol then send!(layout)
         when Proc   then layout.call(self)
       end
       
@@ -231,34 +248,30 @@ module ActionController #:nodoc:
       end
     end
 
-    def render_with_a_layout(options = nil, deprecated_status = nil, deprecated_layout = nil, &block) #:nodoc:
-      template_with_options = options.is_a?(Hash)
-
-      if apply_layout?(template_with_options, options) && (layout = pick_layout(template_with_options, options, deprecated_layout))
-        assert_existence_of_template_file(layout)
+    protected
+      def render_with_a_layout(options = nil, &block) #:nodoc:
+        template_with_options = options.is_a?(Hash)
+        
+        if apply_layout?(template_with_options, options) && (layout = pick_layout(template_with_options, options))
+          assert_existence_of_template_file(layout)
 
-        options = options.merge :layout => false if template_with_options
-        logger.info("Rendering #{options} within #{layout}") if logger
+          options = options.merge :layout => false if template_with_options
+          logger.info("Rendering template within #{layout}") if logger
 
-        if template_with_options
           content_for_layout = render_with_no_layout(options, &block)
-          deprecated_status = options[:status] || deprecated_status
+          erase_render_results
+          add_variables_to_assigns
+          @template.instance_variable_set("@content_for_layout", content_for_layout)
+          response.layout = layout
+          status = template_with_options ? options[:status] : nil
+          render_for_text(@template.render_file(layout, true), status)
         else
-          content_for_layout = render_with_no_layout(options, deprecated_status, &block)
+          render_with_no_layout(options, &block)
         end
-
-        erase_render_results
-        add_variables_to_assigns
-        @template.instance_variable_set("@content_for_layout", content_for_layout)
-        response.layout = layout
-        render_text(@template.render_file(layout, true), deprecated_status)
-      else
-        render_with_no_layout(options, deprecated_status, &block)
       end
-    end
+
 
     private
-    
       def apply_layout?(template_with_options, options)
         return false if options == :update
         template_with_options ?  candidate_for_layout?(options) : !template_exempt_from_layout?
@@ -266,14 +279,12 @@ module ActionController #:nodoc:
 
       def candidate_for_layout?(options)
         (options.has_key?(:layout) && options[:layout] != false) || 
-        options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing).compact.empty? &&
-        !template_exempt_from_layout?(default_template_name(options[:action] || options[:template]))
+          options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing).compact.empty? &&
+          !template_exempt_from_layout?(options[:template] || default_template_name(options[:action]))
       end
 
-      def pick_layout(template_with_options, options, deprecated_layout)
-        if deprecated_layout
-          deprecated_layout
-        elsif template_with_options
+      def pick_layout(template_with_options, options)
+        if template_with_options
           case layout = options[:layout]
             when FalseClass
               nil
@@ -305,9 +316,10 @@ module ActionController #:nodoc:
       # Does a layout directory for this class exist?
       # we cache this info in a class level hash
       def layout_directory?(layout_name)
-        template_path = File.join(self.class.view_root, 'layouts', layout_name)
-        dirname = File.dirname(template_path)
-        self.class.send(:layout_directory_exists_cache)[dirname]
+        view_paths.find do |path| 
+          next unless template_path = Dir[File.join(path, 'layouts', layout_name) + ".*"].first
+          self.class.send!(:layout_directory_exists_cache)[File.dirname(template_path)]
+        end
       end
   end
 end

data/lib/action_controller/mime_responds.rb

@@ -1,7 +1,9 @@
 module ActionController #:nodoc:
   module MimeResponds #:nodoc:
     def self.included(base)
-      base.send(:include, ActionController::MimeResponds::InstanceMethods)
+      base.module_eval do
+        include ActionController::MimeResponds::InstanceMethods
+      end
     end
 
     module InstanceMethods
@@ -11,51 +13,51 @@ module ActionController #:nodoc:
       #   def index
       #     @people = Person.find(:all)
       #   end
-      # 
+      #
       # Here's the same action, with web-service support baked in:
-      # 
+      #
       #   def index
       #     @people = Person.find(:all)
-      # 
+      #
       #     respond_to do |format|
       #       format.html
       #       format.xml { render :xml => @people.to_xml }
       #     end
       #   end
-      # 
-      # What that says is, "if the client wants HTML in response to this action, just respond as we 
-      # would have before, but if the client wants XML, return them the list of people in XML format." 
+      #
+      # What that says is, "if the client wants HTML in response to this action, just respond as we
+      # would have before, but if the client wants XML, return them the list of people in XML format."
       # (Rails determines the desired response format from the HTTP Accept header submitted by the client.)
-      # 
-      # Supposing you have an action that adds a new person, optionally creating their company 
+      #
+      # Supposing you have an action that adds a new person, optionally creating their company
       # (by name) if it does not already exist, without web-services, it might look like this:
-      # 
+      #
       #   def create
       #     @company = Company.find_or_create_by_name(params[:company][:name])
       #     @person  = @company.people.create(params[:person])
-      # 
+      #
       #     redirect_to(person_list_url)
       #   end
-      # 
+      #
       # Here's the same action, with web-service support baked in:
-      # 
+      #
       #   def create
       #     company  = params[:person].delete(:company)
       #     @company = Company.find_or_create_by_name(company[:name])
       #     @person  = @company.people.create(params[:person])
-      # 
+      #
       #     respond_to do |format|
       #       format.html { redirect_to(person_list_url) }
       #       format.js
       #       format.xml  { render :xml => @person.to_xml(:include => @company) }
       #     end
       #   end
-      # 
-      # If the client wants HTML, we just redirect them back to the person list. If they want Javascript 
-      # (wants.js), then it is an RJS request and we render the RJS template associated with this action. 
-      # Lastly, if the client wants XML, we render the created person as XML, but with a twist: we also 
-      # include the person’s company in the rendered XML, so you get something like this:
-      # 
+      #
+      # If the client wants HTML, we just redirect them back to the person list. If they want Javascript
+      # (format.js), then it is an RJS request and we render the RJS template associated with this action.
+      # Lastly, if the client wants XML, we render the created person as XML, but with a twist: we also
+      # include the person's company in the rendered XML, so you get something like this:
+      #
       #   <person>
       #     <id>...</id>
       #     ...
@@ -65,60 +67,54 @@ module ActionController #:nodoc:
       #       ...
       #     </company>
       #   </person>
-      # 
+      #
       # Note, however, the extra bit at the top of that action:
-      # 
+      #
       #   company  = params[:person].delete(:company)
       #   @company = Company.find_or_create_by_name(company[:name])
-      # 
-      # This is because the incoming XML document (if a web-service request is in process) can only contain a 
+      #
+      # This is because the incoming XML document (if a web-service request is in process) can only contain a
       # single root-node. So, we have to rearrange things so that the request looks like this (url-encoded):
-      # 
+      #
       #   person[name]=...&person[company][name]=...&...
-      # 
+      #
       # And, like this (xml-encoded):
-      # 
+      #
       #   <person>
       #     <name>...</name>
       #     <company>
       #       <name>...</name>
       #     </company>
       #   </person>
-      # 
-      # In other words, we make the request so that it operates on a single entity—a person. Then, in the action, 
-      # we extract the company data from the request, find or create the company, and then create the new person 
+      #
+      # In other words, we make the request so that it operates on a single entity's person. Then, in the action,
+      # we extract the company data from the request, find or create the company, and then create the new person
       # with the remaining data.
-      # 
-      # Note that you can define your own XML parameter parser which would allow you to describe multiple entities 
-      # in a single request (i.e., by wrapping them all in a single root note), but if you just go with the flow 
+      #
+      # Note that you can define your own XML parameter parser which would allow you to describe multiple entities
+      # in a single request (i.e., by wrapping them all in a single root note), but if you just go with the flow
       # and accept Rails' defaults, life will be much easier.
-      # 
+      #
       # If you need to use a MIME type which isn't supported by default, you can register your own handlers in
       # environment.rb as follows.
-      # 
+      #
       #   Mime::Type.register "image/jpg", :jpg
       def respond_to(*types, &block)
         raise ArgumentError, "respond_to takes either types or a block, never both" unless types.any? ^ block
         block ||= lambda { |responder| types.each { |type| responder.send(type) } }
-        responder = Responder.new(block.binding)
+        responder = Responder.new(self)
         block.call(responder)
         responder.respond
       end
     end
-    
+
     class Responder #:nodoc:
-      DEFAULT_BLOCKS = [:html, :js, :xml].inject({}) do |blocks, ext|
-        template_extension = (ext == :html ? '' : ".r#{ext}")
-        blocks.update ext => %(Proc.new { render :action => "\#{action_name}#{template_extension}", :content_type => Mime::#{ext.to_s.upcase} })
-      end
-      
-      def initialize(block_binding)
-        @block_binding = block_binding
-        @mime_type_priority = eval(
-          "(params[:format] && Mime::EXTENSION_LOOKUP[params[:format]]) ? " +
-          "[ Mime::EXTENSION_LOOKUP[params[:format]] ] : request.accepts", 
-          block_binding
-        )
+      def initialize(controller)
+        @controller = controller
+        @request    = controller.request
+        @response   = controller.response
+
+        @mime_type_priority = Array(Mime::Type.lookup_by_extension(@request.parameters[:format]) || @request.accepts)
 
         @order     = []
         @responses = {}
@@ -126,54 +122,47 @@ module ActionController #:nodoc:
 
       def custom(mime_type, &block)
         mime_type = mime_type.is_a?(Mime::Type) ? mime_type : Mime::Type.lookup(mime_type.to_s)
-        
+
         @order << mime_type
-        
-        if block_given?
-          @responses[mime_type] = Proc.new do
-            eval "response.content_type = '#{mime_type.to_s}'", @block_binding
-            block.call
-          end
-        else
-          if source = DEFAULT_BLOCKS[mime_type.to_sym]
-            @responses[mime_type] = eval(source, @block_binding)
-          else
-            raise ActionController::RenderError, "Expected a block but none was given for custom mime handler #{mime_type}"
-          end
+
+        @responses[mime_type] = Proc.new do
+          @response.template.template_format = mime_type.to_sym
+          @response.content_type = mime_type.to_s
+          block_given? ? block.call : @controller.send(:render, :action => @controller.action_name)
         end
       end
 
       def any(*args, &block)
         args.each { |type| send(type, &block) }
       end
-      
+
       def method_missing(symbol, &block)
         mime_constant = symbol.to_s.upcase
-        
+
         if Mime::SET.include?(Mime.const_get(mime_constant))
           custom(Mime.const_get(mime_constant), &block)
         else
           super
         end
       end
-      
+
       def respond
         for priority in @mime_type_priority
           if priority == Mime::ALL
             @responses[@order.first].call
             return
           else
-            if priority === @order
+            if @responses[priority]
               @responses[priority].call
               return # mime type match found, be happy and return
             end
           end
         end
-        
+
         if @order.include?(Mime::ALL)
           @responses[Mime::ALL].call
         else
-          eval 'render(:nothing => true, :status => "406 Not Acceptable")', @block_binding
+          @controller.send :head, :not_acceptable
         end
       end
     end

data/lib/action_controller/mime_type.rb

@@ -1,4 +1,8 @@
 module Mime
+  SET              = []
+  EXTENSION_LOOKUP = Hash.new { |h, k| h[k] = Type.new(k) unless k.blank? }
+  LOOKUP           = Hash.new { |h, k| h[k] = Type.new(k) unless k.blank? }
+
   # Encapsulates the notion of a mime type. Can be used at render time, for example, with:
   #
   #   class PostsController < ActionController::Base
@@ -20,7 +24,7 @@ module Mime
       def initialize(order, name, q=nil)
         @order = order
         @name = name.strip
-        q ||= 0.0 if @name == "*/*" # default "*/*" to end of list
+        q ||= 0.0 if @name == Mime::ALL # default wilcard match to end of list
         @q = ((q || 1.0).to_f * 100).to_i
       end
 
@@ -44,22 +48,37 @@ module Mime
         LOOKUP[string]
       end
 
-      def register(string, symbol, synonyms = [])
-        Mime.send :const_set, symbol.to_s.upcase, Type.new(string, symbol, synonyms)
-        SET << Mime.send(:const_get, symbol.to_s.upcase)
-        LOOKUP[string] = EXTENSION_LOOKUP[symbol.to_s] = SET.last        
+      def lookup_by_extension(extension)
+        EXTENSION_LOOKUP[extension]
+      end
+
+      # Registers an alias that's not used on mime type lookup, but can be referenced directly. Especially useful for
+      # rendering different HTML versions depending on the user agent, like an iPhone.
+      def register_alias(string, symbol, extension_synonyms = [])
+        register(string, symbol, [], extension_synonyms, true)
+      end
+
+      def register(string, symbol, mime_type_synonyms = [], extension_synonyms = [], skip_lookup = false)
+        Mime.instance_eval { const_set symbol.to_s.upcase, Type.new(string, symbol, mime_type_synonyms) }
+
+        SET << Mime.const_get(symbol.to_s.upcase)
+
+        ([string] + mime_type_synonyms).each { |string| LOOKUP[string] = SET.last } unless skip_lookup
+        ([symbol.to_s] + extension_synonyms).each { |ext| EXTENSION_LOOKUP[ext] = SET.last }
       end
 
       def parse(accept_header)
         # keep track of creation order to keep the subsequent sort stable
-        index = 0
-        list = accept_header.split(/,/).map! do |i| 
-          AcceptItem.new(index += 1, *i.split(/;\s*q=/))
-        end.sort!
+        list = []
+        accept_header.split(/,/).each_with_index do |header, index| 
+          params = header.split(/;\s*q=/)
+          list << AcceptItem.new(index, *params) unless params.empty?
+        end
+        list.sort!
 
         # Take care of the broken text/xml entry by renaming or deleting it
         text_xml = list.index("text/xml")
-        app_xml = list.index("application/xml")
+        app_xml = list.index(Mime::XML.to_s)
 
         if text_xml && app_xml
           # set the q value to the max of the two
@@ -73,9 +92,9 @@ module Mime
 
           # delete text_xml from the list
           list.delete_at(text_xml)
-  
+
         elsif text_xml
-          list[text_xml].name = "application/xml"
+          list[text_xml].name = Mime::XML.to_s
         end
 
         # Look for more specific xml-based types and sort them ahead of app/xml
@@ -128,73 +147,17 @@ module Mime
     def ==(mime_type)
       (@synonyms + [ self ]).any? { |synonym| synonym.to_s == mime_type.to_s } if mime_type
     end
+    
+    private
+      def method_missing(method, *args)
+        if method.to_s =~ /(\w+)\?$/
+          mime_type = $1.downcase.to_sym
+          mime_type == @symbol || (mime_type == :html && @symbol == :all)
+        else
+          super
+        end
+      end
   end
-
-  ALL   = Type.new "*/*", :all
-  TEXT  = Type.new "text/plain", :text
-  HTML  = Type.new "text/html", :html, %w( application/xhtml+xml )
-  JS    = Type.new "text/javascript", :js, %w( application/javascript application/x-javascript )
-  ICS   = Type.new "text/calendar", :ics
-  CSV   = Type.new "text/csv", :csv
-  XML   = Type.new "application/xml", :xml, %w( text/xml application/x-xml )
-  RSS   = Type.new "application/rss+xml", :rss
-  ATOM  = Type.new "application/atom+xml", :atom
-  YAML  = Type.new "application/x-yaml", :yaml, %w( text/yaml )
-  JSON  = Type.new "application/json", :json, %w( text/x-json )
-
-  SET   = [ ALL, TEXT, HTML, JS, ICS, XML, RSS, ATOM, YAML, JSON ]
-
-  LOOKUP = Hash.new { |h, k| h[k] = Type.new(k) unless k == "" }
-
-  LOOKUP["*/*"]                      = ALL
-
-  LOOKUP["text/plain"]               = TEXT
-
-  LOOKUP["text/html"]                = HTML
-  LOOKUP["application/xhtml+xml"]    = HTML
-
-  LOOKUP["text/javascript"]          = JS
-  LOOKUP["application/javascript"]   = JS
-  LOOKUP["application/x-javascript"] = JS
-
-  LOOKUP["text/calendar"]            = ICS
-
-  LOOKUP["text/csv"]                 = CSV
-
-  LOOKUP["application/xml"]          = XML
-  LOOKUP["text/xml"]                 = XML
-  LOOKUP["application/x-xml"]        = XML
-
-  LOOKUP["text/yaml"]                = YAML
-  LOOKUP["application/x-yaml"]       = YAML
-
-  LOOKUP["application/rss+xml"]      = RSS
-  LOOKUP["application/atom+xml"]     = ATOM
-
-  LOOKUP["application/json"]         = JSON
-  LOOKUP["text/x-json"]              = JSON
-
-
-  EXTENSION_LOOKUP = Hash.new { |h, k| h[k] = Type.new(k) unless k == "" }
-
-  EXTENSION_LOOKUP["html"]  = HTML
-  EXTENSION_LOOKUP["xhtml"] = HTML
-
-  EXTENSION_LOOKUP["txt"]   = TEXT
-
-  EXTENSION_LOOKUP["xml"]   = XML
-
-  EXTENSION_LOOKUP["js"]    = JS
-
-  EXTENSION_LOOKUP["ics"]   = ICS
-
-  EXTENSION_LOOKUP["csv"]   = CSV
-
-  EXTENSION_LOOKUP["yml"]   = YAML
-  EXTENSION_LOOKUP["yaml"]  = YAML
-
-  EXTENSION_LOOKUP["rss"]   = RSS
-  EXTENSION_LOOKUP["atom"]  = ATOM
-
-  EXTENSION_LOOKUP["json"]  = JSON
 end
+
+require 'action_controller/mime_types'