The Missing Link in RJS Chaining
One of the things that make Ruby and Rails my respective current language and web framework of choice is the collective ingenuity that has made building things easy. These folks have thought of everything, gosh darn it, and I get to use it. A good day is when I get something working, and with Ruby and Rails I have a lot of those days. Imagine my dismay however, when on a recent project I had the need for something that wasn't already baked into Rails! The problem occurred when chaining partials together - one partial calling another, calling another, and so on down the line. I find myself doing it a lot these days, updating many parts on a page based upon seemingly simple model changes. Chaining partials together is easy, you just set up some context and render, and repeat. Using Ajax and RJS is now a way of life; I got my baptism in the Javascript waters a long while back, a must for doing esoteric, dynamic rendering. RJS certainly isn't what makes such rendering possible, but it sure makes it easier. Some may think that there are better mechanisms - and maybe in special situations there are - but the simplicity and versatility of generating pieces of web pages using RJS is unparalleled once you understand the subtleties of building Javascript that will be executed in the context of a page. I get the feeling this will be a central characteristic of the next generation of web frameworks. Contextual mismatch is my problem here. Let us say my `foo` partial renders my `bar` partial. The context is established as a hash of variables to values that is built by `foo` and passed into `bar` as the value of the `:locals` key in the `render` call. When `bar` is rendered, the hash is unraveled behind the scenes and the variables become available. All except one that is, the meta-variable that is the locals hash itself! Unless I'm missing something, when you want `foo` to pass whatever `locals` it had received to `bar`, Rails comes up short! There's no way that `foo` can know all the variables that got passed in because this information is lost. The hash has been absorbed and is no longer part of the context! The variables in the `locals` hash that were set up by `foo` have been unpacked and established as the context of `bar`, but the containment itself is no longer available. An argument might be made that making the locals hash available would be wrong; if the code knew it had the locals context, partial-coupling might be considered to be too tight. Perhaps so, but I'd say this really isn't true - assuming context in the form of injected variables is really at the same level of coupling. After all, what Rails is doing for me is just saving me some coding by allowing me to access a variable directly instead of as `locals[:variable]` if the incoming `locals` hash were exposed. The way I see it is that permitting a partial to access the incoming `locals` hash is actually promotes less coupling. A partial could just pass, augment and pass, or create and pass a new hash to the partials it calls - not necessarily knowing to what use the information in the hash might be put, or which partial down the line might be using it. Chaining is about delegating responsibility - entities at intermediate levels really shouldn't have to be concerned with the details of what's happening above and below them. They should be able to pass information along with the understanding that if they don't need it, that doesn't mean that something further along the chain won't. If there's any doubt about this perspective, consider that partials are simply about rendering a page - the page is the real context and many complex renderings of application state changes may be made upon receipt of a seemingly simple event. That's what RJS is really good for - making multiple coordinated changes to a page. Allowing information to be passed down from on high so chained partials can use it according to need in the context of rendering different parts of a page is exactly why RJS is so sweet. Forcing intermediate partials to know what their subordinates need makes them difficult to write, hard to test, and downright painful to change. Of course, just because this isn't automatic doesn't mean I can't do it myself. Passing foo a reference to the `:locals` hash as the value of the `:local_assigns` variable in the `:locals hash` it receives itself, for instance, allows me to pass it as the `:locals` hash to bar. Not a great solution, and it smells a little. Yes, it does mean I have to do some extra work, something Rails has helped me to otherwise avoid, but I can put up with this. Sigh. I sure wish the `locals` hash was already exposed - it is the missing link for chaining. Bottom line: not having access to the incoming locals hash in a partial is a bummer, but it isn't the end of the world.