Rails helpers - Phlex modules vs helpers.*?

[joelmoss]

I'm a little unsure why I should use the helper modules instead of calling helpers on the helpers object. Obviously including a module avoids the need to call helpers.my_helper everywhere, but is there any other benefit?

[joeldrapper]

Good question. We should definitely explain this in the documentation.

The helpers method is a direct proxy to the underlying view helper methods from Rails. helpers literally returns the Rails “view context”, which is the context that an ERB view would execute in. This works pretty well for a helper such as url_for because you can use it like this:

a(href: helpers.url_for(@post)) { "View post" }

However, it falls apart when you try to use a tag helper such as link_to.

helpers.link_to(@post) { "View post" }

This will not do anything because the link_to helper returns a string that they expect you to output by using special ERB tags <%= %>. To use this form Phlex, you’d need to do something like this.

unsafe_raw helpers.link_to(@post) { "View post" }

It’s not nice to have to use unsafe_raw like this, and we shouldn’t get into the habit of using unsafe_raw anywhere in normal application code since it’s so dangerous.

The adapter in Phlex::Rails::Helpers::LinkTo is essentially defined like this:

def link_to(...)
  output = helpers.link_to(...)
  unsafe_raw(output) if output.is_a?(ActiveSupport::SafeBuffer)
end

Additionally, Rails provides helpers such as form_with that yield a builder. In ERB, you would use form_with like this:

<%= form_with(@post) do |f| %>
  <div class="field">
    <%= f.text_field :title %>
  </div>
<% end %>

To do the same in Phlex, ideally you’d want to use this:

form_with(@post) do |f|
  div class: "field" do
    f.text_field :title
  end
end

To make this work, not only do we need form_with to be adapted to output its return value rather than simply return it, but we also need to to yield a specialised form builder object that will output rather than return the value when text_field is called on it.

The Phlex::Rails::Helpers::FormWith adapter does this by yielding a decorated form builder using the decorator pattern. You can see the implementation of the decorator here. The decorator needs to account for the fact that some methods called on the form builder would be expected to return a value, while others (like text_field) would be expected to output something. If you call label on the form builder and pass a block, it yields a decorated label builder too.

All the adapters are designed to adapt the underlying helpers to work naturally in Phlex. They’re opt-in because I expect many of them will not be used in a Phlex context. The tag helpers, for example, are pretty useless unless you’re perhaps in the process of converting something to Phlex and need compatibility.

The idea is that you can include the helpers as and when you need them. And if you use specific helpers a lot, you can include them in your ApplicationView to make them available everywhere.

[Urist-McUristurister]

@joeldrapper is there a way to include all those helpers at once, instead of one-by-one? Because of, you know, convention-over-configuration & stuff ;)

[joeldrapper]

I recommend including the ones you use all the time in an ApplicationComponent class, which all your other views can inherit from. I’d be open to providing useful collections of helpers as modules. I didn’t want to have a module for including them all, though, because some of the helpers are really quite useless in the context of Phlex. tag helpers, for example, are just not necessary.

Some of these adapters exist only for completeness and compatibility with the code you’re in the process of converting.

[Urist-McUristurister]

By "all" I meant all Phlex modules, not all Rails' helpers. Autoloading via method_missing could also be an option. Otherwise there's really a lot of boilerplate that could easily be avoided...

Besides, having a Phlex::Rails::Helpers::All module (or even a macro include_rails_helpers [:all|:link_to|:url_for|etc]) would (hopefully) guarantee that any new module that gets added is also getting included as well.