Unhappy with the rail way of rendering partials

Question

my question considers the partial handling in Rails. I just can't get the reason for some design decisions.

If I render a partial like this:

<%= render partial: 'foo/bar', object: @herbie %>

Where @herbie is an object of class Car. Why is the local variable called bar by default instead of car which - at least for me - would be more reasonable in most cases.

If various partials share a common layout I have to add the layout: ... each time I use render partial:. This seems odd to me! Isn't it more likely to have various partials wich share the same layout then the other way around? Wouldn't it be more reasonable to define the layout within the partial, or to add a to_layout_path method to the ActiveRecord Model?

Update:

I get the point that it might be better to use the partial name, as this is well known in the partial context. However the use of the tags :locals and :as screws up this argumentation.

In an actual case I want to use different partials depending on the state of an object (questions that could be open or closed). I moved the decision which partial to render to the Question.to_partial_path method which seems to be quite elegant. However I named the partials open_question and closed_question and this makes the partial code unreadable. It gets even worse if I consider different types of questions.

I expect that within a partial we always make some presumptions about the model that is passed in. Thus in closed_question I am quit sure that I get a question - thus I would expect the variable to be called question. On the other hand I can imagine situations where we pass in something different that just behaves appropriated (Duck-typing).

My temporal meaning about partials is that within the partial it should be possible to define the name of the given parameter as well as a layout file that is used. The parameter indeed can be realized by introducing a new variable ( question = open_question) which feels a little bit unclean to me.

Answer 1

When you pass in an argument to a method there's no way of knowing what the "name" of that variable is. The only thing the partial rendering method here has at its disposal is the foo/bar name, the object attribute, and some model.

That your model originated in a variable called @car is completely lost in the process of making the call.

It's convention in Rails that the variable used within the partial is the same as the name of the partial itself. You can override this if you want to have non-standard behaviour:

render(partial: 'foo/bar', locals: { car: @car })

As a note, though, going down the non-standard path is usually a bad idea. Whenever possible, just rename your partial to better match your expectations.

Answer 2

This is related: render partial :object vs :locals

The documentation is pretty good: http://api.rubyonrails.org/classes/ActionView/PartialRenderer.html

The default is to name the object after the partial. If you want to be explicit, you can use :as or locals.

render partial: 'foo/bar', locals: {car: @car}
render partial: 'foo/bar', object: @car, as: 'car'