Rails: Unraveling the Mystery of form_with – How Does it Know Which Controller-Action to Invoke?

Rails’ form helpers, particularly form_with, are a marvel of simplicity and convenience. With just a few lines of code, you can create robust and functional forms that interact seamlessly with your controllers. But have you ever stopped to think about how form_with knows which controller-action to invoke when the form is submitted?

In this article, we’ll delve into the inner workings of form_with and explore the magic behind its ability to intuitively determine the correct controller-action to call. Buckle up, and let’s dive in!

The Mysterious Case of the Missing Controller-Action

Let’s start with a simple example. Suppose we have a User model and a corresponding UsersController with a new action to handle the creation of new users.

class UsersController < ApplicationController
  def new
    @user = User.new
  end
end

In our new.html.erb view, we create a form using form_with:

<%= form_with(model: @user, local: true) do |form| %>
  <%#= form.text_field :name %>
  <%#= form.text_field :email %>
  <%#= form.submit %>
<% end %>

Now, when we submit this form, it will send a POST request to the create action of the UsersController. But how does Rails know to do this? We haven’t explicitly specified the controller or action anywhere in the form_with declaration!

The Secret Lies in the Model

The answer lies in the model parameter we passed to form_with. When we specify model: @user, Rails uses the model’s class to determine the correct controller and action to invoke.

In our example, the @user instance variable is an instance of the User class. Rails inspects the class of the model and uses its name to infer the controller and action.

Here’s what happens behind the scenes:

1. Rails asks the model for its persisted? state. Since @user is a new record, persisted? returns false.
2. Rails then checks if the model has a base_class, which in this case is the User class.
3. Rails uses the base_class to determine the controller name by pluralizing the class name and appending "Controller". In our case, this becomes "UsersController".
4. Since the model is new (not persisted), Rails assumes we want to create a new record. It therefore chooses the create action as the intended action for the form submission.

Voilà! With this information, form_with knows to send the form data to the create action of the UsersController.

What About Existing Records?

But what happens when we’re editing an existing record? Suppose we have an edit action in our UsersController:

class UsersController < ApplicationController
  def edit
    @user = User.find(params[:id])
  end
end

In our edit.html.erb view, we create a form using form_with, just like before:

<%= form_with(model: @user, local: true) do |form| %>
  <%#= form.text_field :name %>
  <%#= form.text_field :email %>
  <%#= form.submit %>
<% end %>

This time, when we submit the form, it will send a PATCH request to the update action of the UsersController. Again, we haven’t explicitly specified the controller or action, so how does Rails know what to do?

The answer lies in the persisted? state of the model. Since @user is an existing record, persisted? returns true.

Rails follows a similar process as before, but with a few differences:

1. Rails asks the model for its persisted? state, which returns true since the record exists.
2. Rails uses the base_class to determine the controller name, just like before.
3. Since the model is persisted, Rails assumes we want to update the existing record. It therefore chooses the update action as the intended action for the form submission.

By inferring the controller and action from the model, form_with can automatically generate the correct form attributes, including the HTTP method (PATCH in this case) and the route.

Overriding the Defaults

What if we want to override the default behavior and specify a different controller or action? No problem! form_with provides several options to give us more control:

<%= form_with(model: @user, url: { controller: 'admins', action: 'update_profile' }, local: true) do |form| %>
  <%#= form.text_field :name %>
  <%#= form.text_field :email %>
  <%#= form.submit %>
<% end %>

In this example, we’ve explicitly specified the controller and action using the url option. This tells form_with to send the form data to the update_profile action of the AdminsController, regardless of the model’s persisted? state.

The Power of form_with

As we’ve seen, form_with is an incredibly powerful and intelligent helper. By leveraging the model’s class and persisted? state, it can automatically determine the correct controller and action to invoke, making our lives as developers much easier.

By understanding how form_with works its magic, we can create more robust and efficient forms that interact seamlessly with our controllers. So next time you use form_with, remember the clever magic happening behind the scenes!

Conclusion

In this article, we’ve demystified the inner workings of form_with and explored how it knows which controller-action to invoke. We’ve seen how the model’s class and persisted? state influence the form’s behavior and how we can override the defaults using the url option.

With this newfound understanding, you’ll be better equipped to create intuitive and effective forms in your Rails applications. Happy coding!

Model State	Controller Action
New Record (persisted? == false)	Create
Existing Record (persisted? == true)	Update

Remember, the next time you use form_with, it’s not magic – it’s just Rails being Rails!

Here are the 5 Questions and Answers about “Rails: How does form_with know, which Controller-action to invoke?” :

Frequently Asked Question

Rails newbies and veterans alike, let’s dive into the mysteries of form_with and uncover the secrets of how it knows which controller-action to invoke!