Vendoring Rails 2.3.5

vendor/rails/actionpack/lib/action_controller/layout.rb

@@ -172,16 +172,8 @@ module ActionController #:nodoc:
         @layout_conditions ||= read_inheritable_attribute(:layout_conditions)
       end
 
-      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:
-        Array(view_paths).sum([]) { |path| Dir["#{path}/layouts/**/*"] }
+        Array(view_paths).sum([]) { |path| Dir["#{path.to_str}/layouts/**/*"] }
       end
 
       private
@@ -200,45 +192,43 @@ module ActionController #:nodoc:
         def normalize_conditions(conditions)
           conditions.inject({}) {|hash, (key, value)| hash.merge(key => [value].flatten.map {|action| action.to_s})}
         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
+    def initialize(*args)
+      super
+      @real_format = nil
     end
 
     # Returns the name of the active layout. If the layout was specified as a method reference (through a symbol), this method
     # is called and the return value is used. Likewise if the layout was specified as an inline method (through a proc or method
     # 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(default_template_format)
+    def active_layout(passed_layout = nil, options = {})
+      layout = passed_layout || default_layout
+      return layout if layout.respond_to?(:render)
+
       active_layout = case layout
-        when String then layout
         when Symbol then __send__(layout)
         when Proc   then layout.call(self)
+        else layout
       end
 
-      # Explicitly passed layout names with slashes are looked up relative to the template root,
-      # but auto-discovered layouts derived from a nested controller will contain a slash, though be relative
-      # to the 'layouts' directory so we have to check the file system to infer which case the layout name came from.
-      if active_layout
-        if active_layout.include?('/') && ! layout_directory?(active_layout)
-          active_layout
-        else
-          "layouts/#{active_layout}"
-        end
-      end
+      find_layout(active_layout, default_template_format, options[:html_fallback]) if active_layout
     end
 
     private
-      def candidate_for_layout?(options)
-        options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing, :update).compact.empty? &&
-          !@template.__send__(:_exempt_from_layout?, options[:template] || default_template_name(options[:action]))
+      def default_layout #:nodoc:
+        layout = self.class.read_inheritable_attribute(:layout)
+        return layout unless self.class.read_inheritable_attribute(:auto_layout)
+        find_layout(layout, default_template_format)
+      rescue ActionView::MissingTemplate
+        nil
+      end
+
+      def find_layout(layout, format, html_fallback=false) #:nodoc:
+        view_paths.find_template(layout.to_s =~ /\A\/|layouts\// ? layout : "layouts/#{layout}", format, html_fallback)
+      rescue ActionView::MissingTemplate
+        raise if Mime::Type.lookup_by_extension(format.to_s).html?
       end
 
       def pick_layout(options)
@@ -247,9 +237,9 @@ module ActionController #:nodoc:
           when FalseClass
             nil
           when NilClass, TrueClass
-            active_layout if action_has_layout? && !@template.__send__(:_exempt_from_layout?, default_template_name)
+            active_layout if action_has_layout? && candidate_for_layout?(:template => default_template_name)
           else
-            active_layout(layout)
+            active_layout(layout, :html_fallback => true)
           end
         else
           active_layout if action_has_layout? && candidate_for_layout?(options)
@@ -271,14 +261,26 @@ module ActionController #:nodoc:
         end
       end
 
-      def layout_directory?(layout_name)
-        @template.__send__(:_pick_template, "#{File.join('layouts', layout_name)}.#{@template.template_format}") ? true : false
+      def candidate_for_layout?(options)
+        template = options[:template] || default_template(options[:action])
+        if options.values_at(:text, :xml, :json, :file, :inline, :partial, :nothing, :update).compact.empty?
+          begin
+            template_object = self.view_paths.find_template(template, default_template_format)
+            # this restores the behavior from 2.2.2, where response.template.template_format was reset
+            # to :html for :js requests with a matching html template.
+            # see v2.2.2, ActionView::Base, lines 328-330
+            @real_format = :html if response.template.template_format == :js && template_object.format == "html"
+            !template_object.exempt_from_layout?
+          rescue ActionView::MissingTemplate
+            true
+          end
+        end
       rescue ActionView::MissingTemplate
         false
       end
 
       def default_template_format
-        response.template.template_format
+        @real_format || response.template.template_format
       end
   end
 end