While we've been working on ActionController::Base, there were a few tests for fixes in Rails 2.3 that were mostly hacked in and we were waiting for a cleaner underlying implementation to build them on top of. Today, we finally got all the pending tests passing!
There were basically two categories of pending tests:
Rails 2 had a feature called :exempt_from_layout, which allowed users to specify that a particular kind of layout (defaulting to RJS) should be exempt from layout. The reason for this feature was that people were noticing that their RJS layouts were being wrapped in their HTML layouts.
When I first saw this feature, I had a simple question: "Why were RJS layouts being wrapped in HTML templates in the first place?" And also, if you want an RJS layout (application.js.erb), why shouldn't you be allowed to.
As it turns out, the reason for this was that any number of parts of Rails render templates, and the layout lookup is completely separate. So when it came time to look up a layout, Rails didn't realize that it had just rendered an RJS template (as far as it was concerned, since the available formats allow for HTML and JS, either would do).
The solution: Have template and layout lookup go through a deterministic process, and limit layout lookup to the mime type for the template that was actually rendered (not templates that might have been rendered).
The upshot: exempt_from_layout isn't needed. If you don't want a layout around your RJS templates, don't make an application.js.*. If you do, do. Rails will do the right thing.
An aside: the hardest part of Rails layouts involves when to raise an exception for a missing layout. Since Rails allows layouts to be missing in certain circumstances, making sure an exception is raised in other circumstances is quite tricky. In master, we raise an exception if you explicitly provided a layout (
layout "foo"), and none exist for any MIME type. Implicit layouts or explicit layouts that exist for another MIME are permitted to be absent. The exception to that rule is
render :layout => true, which converts an implicit layout to a required, explicit one.
RJS and HTML
Rails 2 has a bunch of hardcoded rules that allow RJS templates to render HTML. This allows
page[:foo].replace_html :partial => "some_partial" to render some_partial.html.erb.
Effectively, when you got into an RJS template, the acceptable formats list was hardcoded to
[:html]. Again, this blocks the use of RJS partials, and if you supply only an RJS partial, it will not be used (a missing template error would be raised).
When we thought about it, we realized that what is desired is to look for templates matching the mime type of the current template first, and if such a template could not be found, to allow templates matching any mime (with HTML leading the list). If you're in an RJS template and you call
render :partial => "foo", and only a foo.xml.erb exists, we can assume that you mean to render that template.
This handles all of the cases supported by Rails 2, with one small change. If you have both a
html template, the
js template will win inside of RJS. If you didn't want the
js template to win, why did you create it?
That rule now applies to any template. Partials matching the existing mime will be rendered if they exist, but any other mime will work fine as a fallback. So no special rules required for RJS anymore. The same rules apply for other templates (
:file etc.) rendered from the context of another template.
One last thing. If you do
page[:customer].replace_html :partial => "world", an
html template will be required. When we noticed that we could separate out the rules for replace_html from other partials, we realized that we could hardcode more restrictive rules for that specific API than the general API.
And with that, the remaining pending tests pass. I really enjoy being able to solve problems that required hacks in the past by reorganizing the code to produce conceptually nicer solutions.