[Form] Explain how to actually reuse the same form

[ThomasLandauer]

https://symfony.com/doc/current/forms.html#creating-form-classes says:

Besides, forms defined in classes can be reused in multiple actions and services.

But how? What is the best practice here?

• Set up an own controller for the form, then do {{ render(controller('App\\Controller\\...)) }} in Twig
• Or create the form in each controller ($this->createForm(...);), and then (maybe) set its action to some central form processing controller?

I think there should be a dedicated page about this: What are the relevant questions you need to ask yourself before choosing the approach.

[dbrumann]

I think you are conflating to reuse-scenarios. Using classes allows to reuse the form logic by reusing the type inside other form types. The other reuse scenario is using a form in multiple controllers/templates. It might be easier to reuse classes instead of sharing a builder for this, but the approach for both is the same. Both cases are, as far as I remember, covered in the docs. The docs tell you how to set an action in the template or by manipulating the form inside the controller and best practices recommend picking the former, e.g. by setting the action in {{ form_start() }}. The docs also show how to use forms as types in other forms, which shows why it might be handy to have a class instead of using the builder.

At least from my point of view, I don't see much that we can improve around this topic.

[javiereguiluz]

Thomas, when you define a form inside a controller, you cannot reuse that in any way (unless you copy + paste the code in other places). However, when defining the form in a class, you automatically make it reusable. You don't need to do anything; as you said, you just need to call $this->createForm(...);.

For example, you could use the same form to edit the user details in the public website and in the backend. Both are served by different controllers, but use the exact same form (or not the exact same form ... because you can manipulate it in the controller before sending it to the template).

That's why I agree with @dbrumann that the current docs should be enough to see this difference.

[ThomasLandauer]

Well, if 2 of 2 people don't get what I mean, I obviously didn't ask clear enough ;-)

The docs clearly advise to create a form class - I agree with that. But the (unanswered) question is: What's the best practice for the actual reuse of this form class?

Let me expand on the options I'm seeing:

1: Just repeat it in each controller:

$foo = new Foo();
$form = $this->createForm(FooType::class, $foo);
$form->handleRequest($request);
if ($form->isSubmitted() and $form->isValid()) {
    // whatever
}
$render['form'] = $form->createView();

That's at least ~10 lines of copy-pasted code in the controllers, plus more copy-pasting in the templates:

{{ form_start(form) }}
{# ... #}
{{ form_end(form) }}

2: Have just one controller for the form and include() it in each template:

{{ render(controller('App\\Controller\\FooFormController)) }}

---

These 2 were the most extreme cases, using full or zero code duplication. But there are "intermediate" ways too:

3: Different controllers for creating and handling the form:
Repeat this in each controller:

$foo = new Foo();
$form = $this->createForm(FooType::class, $foo);
$render['form'] = $form->createView();

And add the submission logic to just one controller:

$form->handleRequest($request);
if ($form->isSubmitted() and $form->isValid()) {
    // whatever
}

... and in FooType, set the form's action to this "form-handling" controller:

$builder->setAction($this->router->generate('FooHandling'))

4: private method in the controller class:

private function formFoo(Request $request)
{
    $foo = new Foo();
    $form = $this->createForm(FooType::class, $foo);
    $form->handleRequest($request);
    if ($form->isSubmitted() and $form->isValid()) {
        // whatever
        return $this->redirectToRoute('FormFooSuccess', [], Response::HTTP_SEE_OTHER);
    }
    return $form->createView();
}

Then call it in each controller action that needs the form:

$render = $this->formFoo($request);
if ($render instanceof RedirectResponse) {
    return $render;
}
// Continue adding stuff to `$render`

---

I'm sure there are more, but these are the 4 ways I've actually used in practice. So what I'm suggesting would be a page discussing which approach makes sense in which situation (and which is bullshit in any situation ;-) And which are the relevant questions you need to ask yourself.

[dbrumann]

I remember that 3 is discouraged, because when handling submits separately you might still have to just render the form, e.g. when the form validation fails. I think it says so somewhere in the docs. For cases 1, 2 & 4 I think it comes down to personal taste. It's not the purpose of the docs to cover each way to use the component, just give a general overview how to use it and any detail, e.g. whether to reuse via private method, copying the code, etc., is up to users. Maintaining all these examples would be quite a burden.

[ThomasLandauer]

I remember that 3 is discouraged, because when handling submits separately you might still have to just render the form, e.g. when the form validation fails. I think it says so somewhere in the docs.

Yeah, just found that https://symfony.com/doc/current/best_practices.html#use-a-single-action-to-render-and-process-the-form says:

Rendering forms and processing forms are two of the main tasks when handling forms. Both are too similar (most of the times, almost identical), so it’s much simpler to let a single controller action handle everything.

And https://symfony.com/doc/current/forms.html#processing-forms links to that.

Maintaining all these examples would be quite a burden.

Well, maintaining any documentation is a burden ;-) The detail level of the docs is inconsistent - some chapters being very detailed, others being more of a stub than a documentation.
I'm 100% sure that it's not just a matter of personal taste but there are serious drawbacks with each approach - it's just that nobody took the time yet to figure it out systematically ;-)

[ThomasLandauer]

No matter if you agree with the "larger" page discussing various approaches, I just realized that 2 needs to be covered in the documentation in any case! There are three (!) questions on Stack Overflow, all dealing with the same problem (namely the difference between sub-request and master request):

• https://stackoverflow.com/q/45713539/1668200
• https://stackoverflow.com/q/42600672/1668200
• https://stackoverflow.com/q/31468209/1668200

[bizmate]

Can I please ask where are the tips for including forms have gone? What is the best way to re-use forms given that the tips added as part of the PR linked to this ticket have been removed?
Is Re-using forms a bad practice now?

I think forms should also be covered in the Re-Usable bundles section as in my opinion it would be great to explain how to create forms in separate bundles and provide an easy way for them to be included.

[a-k-holod]

@javiereguiluz
Having

• main.html.twig that includes e.g. footer with a form
• and various routes that render sometemplate.html.twig that extends main.html.twig (all rendered from the same controller)

recommended is to use $form = $this->createForm(MainSearchFormType::class); in every function that returns template that is extending the main.html.twig/template with form?