From 569057eed73106908363a8462ce0dafd8b8d5c43 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Tue, 14 Aug 2018 14:57:09 +0200
Subject: [PATCH 01/18] Some wording improvements, clarifications, etc.

---
 form/form_collections.rst | 35 ++++++++++++++++++++++-------------
 1 file changed, 22 insertions(+), 13 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index fa650cbfa82..aaf1ec023b9 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -246,40 +246,49 @@ Allowing "new" Tags with the "Prototype"
 Allowing the user to dynamically add new tags means that you'll need to
 use some JavaScript. Previously you added two tags to your form in the controller.
 Now let the user add as many tag forms as they need directly in the browser.
-This will be done through a bit of JavaScript.
 
 The first thing you need to do is to let the form collection know that it will
 receive an unknown number of tags. So far you've added two tags and the form
-type expects to receive exactly two, otherwise an error will be thrown:
-``This form should not contain extra fields``. To make this flexible,
+type expects to receive exactly two, if it gets more, the following error will be
+thrown: ``This form should not contain extra fields``. To make the number flexible,
 add the ``allow_add`` option to your collection field::
 
     // src/AppBundle/Form/Type/TaskType.php
 
     // ...
-    use Symfony\Component\Form\FormBuilderInterface;
 
     public function buildForm(FormBuilderInterface $builder, array $options)
     {
-        $builder->add('description');
+        // ...
 
         $builder->add('tags', CollectionType::class, array(
-            'entry_type' => TagType::class,
-            'entry_options' => array('label' => false),
+            // ...
             'allow_add' => true,
         ));
     }
 
 In addition to telling the field to accept any number of submitted objects, the
-``allow_add`` also makes a *"prototype"* variable available to you. This "prototype"
-is a little "template" that contains all the HTML to be able to render any
-new "tag" forms. To render it, make the following change to your template:
+``allow_add`` option also makes a ``prototype`` variable available to you. This
+"prototype" is a little "template" that contains all the HTML needed to dynamically
+render any new "tag" forms with JavaScript. To render the prototype, make the following
+change to the existing ``<ul>`` in your template:
 
 .. code-block:: html+twig
 
-    <ul class="tags" data-prototype="{{ form_widget(form.tags.vars.prototype)|e('html_attr') }}">
-        ...
-    </ul>
+    {# app/Resources/views/task/new.html.twig #}
+    
+    {# ... #}
+    
+    {{ form_start(form) }}
+    
+        {# ... #}
+
+        <ul class="tags" data-prototype="{{ form_widget(form.tags.vars.prototype)|e('html_attr') }}">
+            {# ... #}
+        </ul>
+    {{ form_end(form) }}
+
+    {# ... #}
 
 .. note::
 

From 34617e4ff1e9cf34a6785f61151c9d46f515f918 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Tue, 14 Aug 2018 15:20:50 +0200
Subject: [PATCH 02/18] Update form_collections.rst

---
 form/form_collections.rst | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index aaf1ec023b9..8dcb08d7219 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -290,11 +290,11 @@ change to the existing ``<ul>`` in your template:
 
     {# ... #}
 
-.. note::
+On the rendered page, the result will look something like this:
 
-    If you render your whole "tags" sub-form at once (e.g. ``form_row(form.tags)``),
-    then the prototype is automatically available on the outer ``div`` as
-    the ``data-prototype`` attribute, similar to what you see above.
+.. code-block:: html
+
+    <ul class="tags" data-prototype="&lt;div&gt;&lt;label class=&quot; required&quot;&gt;__name__&lt;/label&gt;&lt;div id=&quot;task_tags___name__&quot;&gt;&lt;div&gt;&lt;label for=&quot;task_tags___name___name&quot; class=&quot; required&quot;&gt;Name&lt;/label&gt;&lt;input type=&quot;text&quot; id=&quot;task_tags___name___name&quot; name=&quot;task[tags][__name__][name]&quot; required=&quot;required&quot; maxlength=&quot;255&quot; /&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;">
 
 .. tip::
 
@@ -308,11 +308,11 @@ change to the existing ``<ul>`` in your template:
 
         {{ form_widget(form.tags.vars.prototype.name)|e }}
 
-On the rendered page, the result will look something like this:
-
-.. code-block:: html
+.. note::
 
-    <ul class="tags" data-prototype="&lt;div&gt;&lt;label class=&quot; required&quot;&gt;__name__&lt;/label&gt;&lt;div id=&quot;task_tags___name__&quot;&gt;&lt;div&gt;&lt;label for=&quot;task_tags___name___name&quot; class=&quot; required&quot;&gt;Name&lt;/label&gt;&lt;input type=&quot;text&quot; id=&quot;task_tags___name___name&quot; name=&quot;task[tags][__name__][name]&quot; required=&quot;required&quot; maxlength=&quot;255&quot; /&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;">
+    You can also render the entire "tags" sub-form at once (e.g. ``form_row(form.tags)``).
+    In this case the ``data-prototype`` attribute is automatically added to the containing ``div``,
+    and you need to adjust the following JavaScript accordingly.
 
 The goal of this section will be to use JavaScript to read this attribute
 and dynamically add new tag forms when the user clicks a "Add a tag" link.

From 13922f1e2d1411f2bb8e6f1b95d52e87a2b24514 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Tue, 14 Aug 2018 18:28:54 +0200
Subject: [PATCH 03/18] Reworked the JavaScript

Reason: I think the docs should show a *minimal* working example. The user needs to customize it anyway, so coming up with a bells-and-whistles solution only makes the entire process look more complicated than it is.

I entered the "Add new tag" link into the HTML directly, cause I couldn't see any benefit of having it added dynamically.

I didn't update the JSFiddle though.

I'm not finished yet - this code might break the JavaScript further down the page (the "remove tag" link)
---
 form/form_collections.rst | 91 ++++++++++++++++-----------------------
 1 file changed, 36 insertions(+), 55 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 8dcb08d7219..96e5ac87ca5 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -314,82 +314,62 @@ On the rendered page, the result will look something like this:
     In this case the ``data-prototype`` attribute is automatically added to the containing ``div``,
     and you need to adjust the following JavaScript accordingly.
 
-The goal of this section will be to use JavaScript to read this attribute
-and dynamically add new tag forms when the user clicks a "Add a tag" link.
-To make things simple, this example uses jQuery and assumes you have it included
-somewhere on your page.
+Now we need some JavaScript to read this attribute and dynamically add new tag forms
+when the user clicks an "Add a tag" link. To make things simple, this example uses `jQuery`_.
 
-Add a ``script`` tag somewhere on your page so you can start writing some JavaScript.
+First, add the link somewhere in your template:
 
-First, add a link to the bottom of the "tags" list via JavaScript. Second,
-bind to the "click" event of that link so you can add a new tag form (``addTagForm()``
-will be show next):
+.. code-block:: html+twig
 
-.. code-block:: javascript
+    {# app/Resources/views/task/new.html.twig #}
+    
+    {# ... #}
+    
+    {{ form_start(form) }}
+    
+        {# ... #}
 
-    var $collectionHolder;
+        <a href="#" class="add_tag_link">Add a tag</a>
+        
+    {{ form_end(form) }}
 
-    // setup an "add a tag" link
-    var $addTagButton = $('<button type="button" class="add_tag_link">Add a tag</button>');
-    var $newLinkLi = $('<li></li>').append($addTagButton);
+    {# ... #}
 
-    jQuery(document).ready(function() {
-        // Get the ul that holds the collection of tags
-        $collectionHolder = $('ul.tags');
+Now add the required functionality with JavaScript:
 
-        // add the "add a tag" anchor and li to the tags ul
-        $collectionHolder.append($newLinkLi);
+.. code-block:: javascript
 
-        // count the current form inputs we have (e.g. 2), use that as the new
-        // index when inserting a new item (e.g. 2)
-        $collectionHolder.data('index', $collectionHolder.find(':input').length);
+    // JavaScript
 
-        $addTagButton.on('click', function(e) {
-            // add a new tag form (see next code block)
-            addTagForm($collectionHolder, $newLinkLi);
+    $(document).ready(function() {
+        $('.add_tag_link').click(function() {
+            addTagForm();
         });
     });
+    
+    function addTagForm() {
+        var collectionHolder = 'ul.tags';
+        // Set up a new `li` with the contents of the prototype:
+        var newForm = '<li>' + $(collectionHolder).data('prototype') + '</li>';
 
-The ``addTagForm()`` function's job will be to use the ``data-prototype`` attribute
-to dynamically add a new form when this link is clicked. The ``data-prototype``
-HTML contains the tag ``text`` input element with a name of ``task[tags][__name__][name]``
-and id of ``task_tags___name___name``. The ``__name__`` is a little "placeholder",
-which you'll replace with a unique, incrementing number (e.g. ``task[tags][3][name]``).
-
-The actual code needed to make this all work can vary quite a bit, but here's
-one example:
-
-.. code-block:: javascript
-
-    function addTagForm($collectionHolder, $newLinkLi) {
-        // Get the data-prototype explained earlier
-        var prototype = $collectionHolder.data('prototype');
+        // Get the index of the new `li`:
+        var index = $(collectionHolder + ' li').length;
 
-        // get the new index
-        var index = $collectionHolder.data('index');
+        // Replace `__name__` in the prototype's HTML with the current index:
+        newForm = newForm.replace(/__name__/g, index);
 
-        var newForm = prototype;
         // You need this only if you didn't set 'label' => false in your tags field in TaskType
         // Replace '__name__label__' in the prototype's HTML to
         // instead be a number based on how many items we have
         // newForm = newForm.replace(/__name__label__/g, index);
 
-        // Replace '__name__' in the prototype's HTML to
-        // instead be a number based on how many items we have
-        newForm = newForm.replace(/__name__/g, index);
-
-        // increase the index with one for the next item
-        $collectionHolder.data('index', index + 1);
-
-        // Display the form in the page in an li, before the "Add a tag" link li
-        var $newFormLi = $('<li></li>').append(newForm);
-        $newLinkLi.before($newFormLi);
+        $(collectionHolder).append(newForm);        
     }
 
-.. note::
-
-    It is better to separate your JavaScript in real JavaScript files than
-    to write it inside the HTML as is done here.
+The ``data-prototype`` HTML contains the tag ``text`` input element with a name of
+``task[tags][__name__][name]`` and id of ``task_tags___name___name``. The ``__name__``
+is a little "placeholder", which is replaced with a unique, incrementing number
+(e.g. ``task[tags][3][name]``).
 
 Now, each time a user clicks the ``Add a tag`` link, a new sub form will
 appear on the page. When the form is submitted, any new tag forms will be converted
@@ -726,5 +706,6 @@ the relationship between the removed ``Tag`` and ``Task`` object.
     an element in the collection and customizing the buttons is also possible.
 
 .. _`Owning Side and Inverse Side`: http://docs.doctrine-project.org/en/latest/reference/unitofwork-associations.html
+.. _`jQuery`: http://jquery.com/
 .. _`JSFiddle`: http://jsfiddle.net/847Kf/4/
 .. _`symfony-collection`: https://github.com/ninsuo/symfony-collection

From f7ad1a3299cd6233e89f09c03f566d966b91a2c6 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Wed, 15 Aug 2018 16:03:36 +0200
Subject: [PATCH 04/18] Finished JavaScript rework

---
 form/form_collections.rst | 124 ++++++++++++++++++--------------------
 1 file changed, 59 insertions(+), 65 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 96e5ac87ca5..267c7c9bc8e 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -12,13 +12,13 @@ that Task, right inside the same form.
 .. note::
 
     In this article, it's loosely assumed that you're using Doctrine as your
-    database store. But if you're not using Doctrine (e.g. Propel or just
-    a database connection), it's all very similar. There are only a few parts
-    of this tutorial that really care about "persistence".
+    database store. But if you're not using Doctrine, it's all very similar.
+    There are only a few parts of this tutorial that really care about
+    persistence.
 
     If you *are* using Doctrine, you'll need to add the Doctrine metadata,
-    including the ``ManyToMany`` association mapping definition on the Task's
-    ``tags`` property.
+    including the ``ManyToMany`` association mapping definition on the
+    ``tags`` property of ``Task``.
 
 First, suppose that each ``Task`` belongs to multiple ``Tag`` objects. Start
 by creating a simple ``Task`` class::
@@ -186,9 +186,9 @@ In your controller, you'll create a new form from the ``TaskType``::
 
 The corresponding template is now able to render both the ``description``
 field for the task form as well as all the ``TagType`` forms for any tags
-that are already related to this ``Task``. In the above controller, I added
-some dummy code so that you can see this in action (since a ``Task`` has
-zero tags when first created).
+that are already related to this ``Task``. The above controller has some
+dummy code so that you can see this in action (since a newly created ``Task``
+has zero tags).
 
 .. code-block:: html+twig
 
@@ -211,7 +211,7 @@ zero tags when first created).
 
     {# ... #}
 
-When the user submits the form, the submitted data for the ``tags`` field are
+When the user submits the form, the submitted data for the ``tags`` field is
 used to construct an ``ArrayCollection`` of ``Tag`` objects, which is then set
 on the ``tag`` field of the ``Task`` instance.
 
@@ -220,12 +220,12 @@ and can be persisted to the database or used however you need.
 
 So far, this works great, but this doesn't allow you to dynamically add new
 tags or delete existing tags. So, while editing existing tags will work
-great, your user can't actually add any new tags yet.
+great, your users can't actually add any new tags yet.
 
 .. caution::
 
     In this article, you embed only one collection, but you are not limited
-    to this. You can also embed nested collection as many levels down as you
+    to this. You can also embed nested collections as many levels down as you
     like. But if you use Xdebug in your development setup, you may receive
     a ``Maximum function nesting level of '100' reached, aborting!`` error.
     This is due to the ``xdebug.max_nesting_level`` PHP setting, which defaults
@@ -245,33 +245,31 @@ Allowing "new" Tags with the "Prototype"
 
 Allowing the user to dynamically add new tags means that you'll need to
 use some JavaScript. Previously you added two tags to your form in the controller.
-Now let the user add as many tag forms as they need directly in the browser.
+Now let the users add as many tag forms as they need directly in the browser.
 
 The first thing you need to do is to let the form collection know that it will
 receive an unknown number of tags. So far you've added two tags and the form
-type expects to receive exactly two, if it gets more, the following error will be
+type expects to receive exactly two. If it gets more, the following error will be
 thrown: ``This form should not contain extra fields``. To make the number flexible,
 add the ``allow_add`` option to your collection field::
 
     // src/AppBundle/Form/Type/TaskType.php
 
     // ...
-
     public function buildForm(FormBuilderInterface $builder, array $options)
     {
         // ...
-
         $builder->add('tags', CollectionType::class, array(
             // ...
             'allow_add' => true,
         ));
     }
 
-In addition to telling the field to accept any number of submitted objects, the
-``allow_add`` option also makes a ``prototype`` variable available to you. This
+In addition to telling the field to accept any number of submitted objects,
+``allow_add`` also makes a ``prototype`` variable available to you. This
 "prototype" is a little "template" that contains all the HTML needed to dynamically
 render any new "tag" forms with JavaScript. To render the prototype, make the following
-change to the existing ``<ul>`` in your template:
+change to the existing ``<ul>`` in your template::
 
 .. code-block:: html+twig
 
@@ -296,6 +294,12 @@ On the rendered page, the result will look something like this:
 
     <ul class="tags" data-prototype="&lt;div&gt;&lt;label class=&quot; required&quot;&gt;__name__&lt;/label&gt;&lt;div id=&quot;task_tags___name__&quot;&gt;&lt;div&gt;&lt;label for=&quot;task_tags___name___name&quot; class=&quot; required&quot;&gt;Name&lt;/label&gt;&lt;input type=&quot;text&quot; id=&quot;task_tags___name___name&quot; name=&quot;task[tags][__name__][name]&quot; required=&quot;required&quot; maxlength=&quot;255&quot; /&gt;&lt;/div&gt;&lt;/div&gt;&lt;/div&gt;">
 
+
+.. seealso::
+
+    If you want to customize the HTML code in the prototype, see
+    :ref:`form-custom-prototype`.
+
 .. tip::
 
     The ``form.tags.vars.prototype`` is a form element that looks and feels just
@@ -342,7 +346,8 @@ Now add the required functionality with JavaScript:
     // JavaScript
 
     $(document).ready(function() {
-        $('.add_tag_link').click(function() {
+        $('.add_tag_link').click(function(e) {
+            e.preventDefault();
             addTagForm();
         });
     });
@@ -362,8 +367,10 @@ Now add the required functionality with JavaScript:
         // Replace '__name__label__' in the prototype's HTML to
         // instead be a number based on how many items we have
         // newForm = newForm.replace(/__name__label__/g, index);
-
-        $(collectionHolder).append(newForm);        
+        
+        // Convert the HTML string to a jQuery object. This is needed later, when we add a "delete this tag" link:
+        var $newForm = $(newForm);
+        $(collectionHolder).append($newForm);        
     }
 
 The ``data-prototype`` HTML contains the tag ``text`` input element with a name of
@@ -371,30 +378,23 @@ The ``data-prototype`` HTML contains the tag ``text`` input element with a name
 is a little "placeholder", which is replaced with a unique, incrementing number
 (e.g. ``task[tags][3][name]``).
 
-Now, each time a user clicks the ``Add a tag`` link, a new sub form will
-appear on the page. When the form is submitted, any new tag forms will be converted
-into new ``Tag`` objects and added to the ``tags`` property of the ``Task`` object.
-
 .. seealso::
 
     You can find a working example in this `JSFiddle`_.
 
-.. seealso::
-
-    If you want to customize the HTML code in the prototype, read
-    :ref:`form-custom-prototype`.
+Now, each time a user clicks the ``Add a tag`` link, a new sub form will
+appear on the page. When the form is submitted, any new tag forms will be converted
+into new ``Tag`` objects and added to the ``tags`` property of the ``Task`` object.
 
 To make handling these new tags easier, add an "adder" and a "remover" method
 for the tags in the ``Task`` class::
 
     // src/AppBundle/Entity/Task.php
-    namespace AppBundle\Entity;
 
     // ...
     class Task
     {
         // ...
-
         public function addTag(Tag $tag)
         {
             $this->tags->add($tag);
@@ -402,7 +402,7 @@ for the tags in the ``Task`` class::
 
         public function removeTag(Tag $tag)
         {
-            // ...
+            // empty for now
         }
     }
 
@@ -414,7 +414,6 @@ Next, add a ``by_reference`` option to the ``tags`` field and set it to ``false`
     public function buildForm(FormBuilderInterface $builder, array $options)
     {
         // ...
-
         $builder->add('tags', CollectionType::class, array(
             // ...
             'by_reference' => false,
@@ -494,12 +493,12 @@ you will learn about next!).
 
     A second potential issue deals with the `Owning Side and Inverse Side`_
     of Doctrine relationships. In this example, if the "owning" side of the
-    relationship is "Task", then persistence will work fine as the tags are
-    properly added to the Task. However, if the owning side is on "Tag", then
+    relationship is ``Task``, then persistence will work fine as the tags are
+    properly added to the task. However, if the owning side is on ``Tag``, then
     you'll need to do a little bit more work to ensure that the correct side
     of the relationship is modified.
 
-    The trick is to make sure that the single "Task" is set on each "Tag".
+    The trick is to make sure that the single ``Task`` is set on each ``Tag``.
     One easy way to do this is to add some extra logic to ``addTag()``,
     which is called by the form type since ``by_reference`` is set to
     ``false``::
@@ -532,11 +531,10 @@ you will learn about next!).
 
 .. _form-collections-remove:
 
-Allowing Tags to be Removed
+Allowing Tags to Be Removed
 ---------------------------
 
 The next step is to allow the deletion of a particular item in the collection.
-The solution is similar to allowing tags to be added.
 
 Start by adding the ``allow_delete`` option in the form Type::
 
@@ -546,7 +544,6 @@ Start by adding the ``allow_delete`` option in the form Type::
     public function buildForm(FormBuilderInterface $builder, array $options)
     {
         // ...
-
         $builder->add('tags', CollectionType::class, array(
             // ...
             'allow_delete' => true,
@@ -561,60 +558,57 @@ Now, you need to put some code into the ``removeTag()`` method of ``Task``::
     class Task
     {
         // ...
-
         public function removeTag(Tag $tag)
         {
             $this->tags->removeElement($tag);
         }
     }
 
-Template Modifications
-~~~~~~~~~~~~~~~~~~~~~~
-
 The ``allow_delete`` option means that if an item of a collection
 isn't sent on submission, the related data is removed from the collection
 on the server. In order for this to work in an HTML form, you must remove
 the DOM element for the collection item to be removed, before submitting
 the form.
 
-First, add a "delete this tag" link to each tag form:
+First, prepare a JavaScript function that adds a "delete this tag" link::
 
 .. code-block:: javascript
 
-    jQuery(document).ready(function() {
-        // Get the ul that holds the collection of tags
-        $collectionHolder = $('ul.tags');
+    function addDeleteLink($tagFormLi) {
+        var $removeFormButton = $('<a href="#">Delete this tag</a>');
+        $tagFormLi.append($removeFormButton);
 
-        // add a delete link to all of the existing tag form li elements
-        $collectionHolder.find('li').each(function() {
-            addTagFormDeleteLink($(this));
+        $removeFormButton.click(function(e) {
+            e.preventDefault();
+            $tagFormLi.remove();
         });
+    }
 
-        // ... the rest of the block from above
-    });
+Now call this function in ``addTagForm()`` function from above:
+
+.. code-block:: javascript
 
     function addTagForm() {
         // ...
-
-        // add a delete link to the new form
-        addTagFormDeleteLink($newFormLi);
+        addDeleteLink($newForm);
     }
 
-The ``addTagFormDeleteLink()`` function will look something like this:
+This adds the "delete" link to all tag forms that were created by JavaScript
+(i.e. after the user clicked the "add new tag" link from above). But what
+about any tags that already existed on the server? You could easily add the
+"delete" link inside the ``for`` loop of your Twig template, but you'd have
+to adjust the JavaScript a little. Or you can just create them with JavaScript
+too:
 
 .. code-block:: javascript
 
-    function addTagFormDeleteLink($tagFormLi) {
-        var $removeFormButton = $('<button type="button">Delete this tag</button>');
-        $tagFormLi.append($removeFormButton);
-
-        $removeFormButton.on('click', function(e) {
-            // remove the li for the tag form
-            $tagFormLi.remove();
+    $(document).ready(function() {
+        $('ul.tags').find('li').each(function() {
+            addDeleteLink($(this));
         });
-    }
+    });
 
-When a tag form is removed from the DOM and submitted, the removed ``Tag`` object
+When a tag form is removed from the DOM on submission, the removed ``Tag`` object
 will not be included in the collection passed to ``setTags()``. Depending on
 your persistence layer, this may or may not be enough to actually remove
 the relationship between the removed ``Tag`` and ``Task`` object.

From 885a902cfabdd13d57ee2d537c28a89ba63c196f Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 16 Aug 2018 13:17:34 +0200
Subject: [PATCH 05/18] Updated link to Doctrine

---
 form/form_collections.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 267c7c9bc8e..7d57c5a62d6 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -699,7 +699,7 @@ the relationship between the removed ``Tag`` and ``Task`` object.
     elements of the collection. More advanced functionality like moving or duplicating
     an element in the collection and customizing the buttons is also possible.
 
-.. _`Owning Side and Inverse Side`: http://docs.doctrine-project.org/en/latest/reference/unitofwork-associations.html
+.. _`Owning Side and Inverse Side`: https://www.doctrine-project.org/projects/doctrine-orm/en/current/reference/unitofwork-associations.html
 .. _`jQuery`: http://jquery.com/
 .. _`JSFiddle`: http://jsfiddle.net/847Kf/4/
 .. _`symfony-collection`: https://github.com/ninsuo/symfony-collection

From 5a219618a09e14d66663926c8a35e116099a9d60 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 16 Aug 2018 13:53:48 +0200
Subject: [PATCH 06/18] More improvments :-)

---
 form/form_collections.rst | 37 +++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 7d57c5a62d6..5785f3d9269 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -435,10 +435,9 @@ you will learn about next!).
 
 .. sidebar:: Doctrine: Cascading Relations and saving the "Inverse" side
 
-    To save the new tags with Doctrine, you need to consider a couple more
-    things. First, unless you iterate over all of the new ``Tag`` objects and
-    call ``$entityManager->persist($tag)`` on each, you'll receive an error from
-    Doctrine:
+    To save the new tags with Doctrine, you need to consider two more things. First,
+    unless you iterate over all of the new ``Tag`` objects and call
+    ``$entityManager->persist($tag)`` on each, you'll receive this error from Doctrine:
 
         A new entity was found through the relationship
         ``AppBundle\Entity\Task#tags`` that was not configured to
@@ -446,7 +445,7 @@ you will learn about next!).
 
     To fix this, you may choose to "cascade" the persist operation automatically
     from the ``Task`` object to any related tags. To do this, add the ``cascade``
-    option to your ``ManyToMany`` metadata:
+    option to your mapping:
 
     .. configuration-block::
 
@@ -491,17 +490,16 @@ you will learn about next!).
                 </entity>
             </doctrine-mapping>
 
-    A second potential issue deals with the `Owning Side and Inverse Side`_
-    of Doctrine relationships. In this example, if the "owning" side of the
-    relationship is ``Task``, then persistence will work fine as the tags are
-    properly added to the task. However, if the owning side is on ``Tag``, then
-    you'll need to do a little bit more work to ensure that the correct side
-    of the relationship is modified.
-
-    The trick is to make sure that the single ``Task`` is set on each ``Tag``.
-    One easy way to do this is to add some extra logic to ``addTag()``,
-    which is called by the form type since ``by_reference`` is set to
-    ``false``::
+    The second potential issue deals with the `Owning Side and Inverse Side`_
+    of Doctrine relationships. In the many-to-many association of this example,
+    if the "owning" side of the relationship is ``Task``, then persistence will
+    work fine as the tags are properly added to the task.
+    
+    However, if you have a **one-to-many** association, the owning side is always the
+    "many" side (``Tag`` in our example). In this case you have to make sure that
+    the ``Task`` is set on each ``Tag``. This can be done by adding a single line
+    to the "adder" we created above, which is called by the form type since
+    ``by_reference`` is set to ``false``::
 
         // src/AppBundle/Entity/Task.php
 
@@ -513,15 +511,14 @@ you will learn about next!).
             // for a many-to-one association:
             $tag->setTask($this);
 
-            $this->tags->add($tag);
+            // ...
         }
 
-    If you're going for ``addTask()``, just make sure you have an appropriate method
-    that looks something like this::
+    In case of the many-to-many association, just make sure you have an appropriate
+    method inside ``Tag`` that looks something like this::
 
         // src/AppBundle/Entity/Tag.php
 
-        // ...
         public function addTask(Task $task)
         {
             if (!$this->tasks->contains($task)) {

From c64625f1cb08ddac90b0860e1b5b2e06f433252a Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Mon, 3 Sep 2018 13:30:00 +0200
Subject: [PATCH 07/18] Removed colon

See https://github.com/symfony/symfony-docs/pull/10180#pullrequestreview-151700650
---
 form/form_collections.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 5785f3d9269..fa046e83fca 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -269,7 +269,7 @@ In addition to telling the field to accept any number of submitted objects,
 ``allow_add`` also makes a ``prototype`` variable available to you. This
 "prototype" is a little "template" that contains all the HTML needed to dynamically
 render any new "tag" forms with JavaScript. To render the prototype, make the following
-change to the existing ``<ul>`` in your template::
+change to the existing ``<ul>`` in your template:
 
 .. code-block:: html+twig
 

From 2f57e82d4e2e6496b24d0ef8acd1b91538496395 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Tue, 4 Sep 2018 13:28:17 +0200
Subject: [PATCH 08/18] Removed another colon

See https://github.com/symfony/symfony-docs/pull/10180#pullrequestreview-151940520
---
 form/form_collections.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index fa046e83fca..3a901f597d1 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -567,7 +567,7 @@ on the server. In order for this to work in an HTML form, you must remove
 the DOM element for the collection item to be removed, before submitting
 the form.
 
-First, prepare a JavaScript function that adds a "delete this tag" link::
+First, prepare a JavaScript function that adds a "delete this tag" link:
 
 .. code-block:: javascript
 

From 11c2c4511edd2cc9b286d69945f4a9f0b7acefb8 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 15:07:59 +0200
Subject: [PATCH 09/18] Minor

---
 form/form_collections.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 3a901f597d1..ba6502ec390 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -114,8 +114,8 @@ form itself, create a form for the ``Task`` class.
 Notice that you embed a collection of ``TagType`` forms using the
 :doc:`CollectionType </reference/forms/types/collection>` field::
 
-    // src/AppBundle/Form/Type/TaskType.php
-    namespace AppBundle\Form\Type;
+    // src/AppBundle/Form/TaskType.php
+    namespace AppBundle\Form;
 
     use AppBundle\Entity\Task;
     use Symfony\Component\Form\AbstractType;
@@ -150,7 +150,7 @@ In your controller, you'll create a new form from the ``TaskType``::
 
     use AppBundle\Entity\Task;
     use AppBundle\Entity\Tag;
-    use AppBundle\Form\Type\TaskType;
+    use AppBundle\Form\TaskType;
     use Symfony\Component\HttpFoundation\Request;
     use Symfony\Bundle\FrameworkBundle\Controller\Controller;
 

From 7159dbee7cc79216a818ffe63bd885443ef40cd7 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 15:13:39 +0200
Subject: [PATCH 10/18] Removed AppBundle from code samples

---
 form/form_collections.rst | 60 +++++++++++++++++++--------------------
 1 file changed, 30 insertions(+), 30 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index ba6502ec390..7af248cf4bf 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -23,8 +23,8 @@ that Task, right inside the same form.
 First, suppose that each ``Task`` belongs to multiple ``Tag`` objects. Start
 by creating a simple ``Task`` class::
 
-    // src/AppBundle/Entity/Task.php
-    namespace AppBundle\Entity;
+    // src/App/Entity/Task.php
+    namespace App\Entity;
 
     use Doctrine\Common\Collections\ArrayCollection;
 
@@ -64,8 +64,8 @@ by creating a simple ``Task`` class::
 Now, create a ``Tag`` class. As you saw above, a ``Task`` can have many ``Tag``
 objects::
 
-    // src/AppBundle/Entity/Tag.php
-    namespace AppBundle\Entity;
+    // src/App/Entity/Tag.php
+    namespace App\Entity;
 
     class Tag
     {
@@ -84,10 +84,10 @@ objects::
 
 Then, create a form class so that a ``Tag`` object can be modified by the user::
 
-    // src/AppBundle/Form/Type/TagType.php
-    namespace AppBundle\Form\Type;
+    // src/App/Form/TagType.php
+    namespace App\Form;
 
-    use AppBundle\Entity\Tag;
+    use App\Entity\Tag;
     use Symfony\Component\Form\AbstractType;
     use Symfony\Component\Form\FormBuilderInterface;
     use Symfony\Component\OptionsResolver\OptionsResolver;
@@ -114,10 +114,10 @@ form itself, create a form for the ``Task`` class.
 Notice that you embed a collection of ``TagType`` forms using the
 :doc:`CollectionType </reference/forms/types/collection>` field::
 
-    // src/AppBundle/Form/TaskType.php
-    namespace AppBundle\Form;
+    // src/App/Form/TaskType.php
+    namespace App\Form;
 
-    use AppBundle\Entity\Task;
+    use App\Entity\Task;
     use Symfony\Component\Form\AbstractType;
     use Symfony\Component\Form\FormBuilderInterface;
     use Symfony\Component\OptionsResolver\OptionsResolver;
@@ -145,12 +145,12 @@ Notice that you embed a collection of ``TagType`` forms using the
 
 In your controller, you'll create a new form from the ``TaskType``::
 
-    // src/AppBundle/Controller/TaskController.php
-    namespace AppBundle\Controller;
+    // src/App/Controller/TaskController.php
+    namespace App\Controller;
 
-    use AppBundle\Entity\Task;
-    use AppBundle\Entity\Tag;
-    use AppBundle\Form\TaskType;
+    use App\Entity\Task;
+    use App\Entity\Tag;
+    use App\Form\TaskType;
     use Symfony\Component\HttpFoundation\Request;
     use Symfony\Bundle\FrameworkBundle\Controller\Controller;
 
@@ -253,7 +253,7 @@ type expects to receive exactly two. If it gets more, the following error will b
 thrown: ``This form should not contain extra fields``. To make the number flexible,
 add the ``allow_add`` option to your collection field::
 
-    // src/AppBundle/Form/Type/TaskType.php
+    // src/App/Form/TaskType.php
 
     // ...
     public function buildForm(FormBuilderInterface $builder, array $options)
@@ -389,7 +389,7 @@ into new ``Tag`` objects and added to the ``tags`` property of the ``Task`` obje
 To make handling these new tags easier, add an "adder" and a "remover" method
 for the tags in the ``Task`` class::
 
-    // src/AppBundle/Entity/Task.php
+    // src/App/Entity/Task.php
 
     // ...
     class Task
@@ -408,7 +408,7 @@ for the tags in the ``Task`` class::
 
 Next, add a ``by_reference`` option to the ``tags`` field and set it to ``false``::
 
-    // src/AppBundle/Form/Type/TaskType.php
+    // src/App/Form/TaskType.php
 
     // ...
     public function buildForm(FormBuilderInterface $builder, array $options)
@@ -440,7 +440,7 @@ you will learn about next!).
     ``$entityManager->persist($tag)`` on each, you'll receive this error from Doctrine:
 
         A new entity was found through the relationship
-        ``AppBundle\Entity\Task#tags`` that was not configured to
+        ``App\Entity\Task#tags`` that was not configured to
         cascade persist operations for entity...
 
     To fix this, you may choose to "cascade" the persist operation automatically
@@ -451,7 +451,7 @@ you will learn about next!).
 
         .. code-block:: php-annotations
 
-            // src/AppBundle/Entity/Task.php
+            // src/App/Entity/Task.php
 
             // ...
 
@@ -462,8 +462,8 @@ you will learn about next!).
 
         .. code-block:: yaml
 
-            # src/AppBundle/Resources/config/doctrine/Task.orm.yml
-            AppBundle\Entity\Task:
+            # src/App/Resources/config/doctrine/Task.orm.yml
+            App\Entity\Task:
                 type: entity
                 # ...
                 oneToMany:
@@ -473,14 +473,14 @@ you will learn about next!).
 
         .. code-block:: xml
 
-            <!-- src/AppBundle/Resources/config/doctrine/Task.orm.xml -->
+            <!-- src/App/Resources/config/doctrine/Task.orm.xml -->
             <?xml version="1.0" encoding="UTF-8" ?>
             <doctrine-mapping xmlns="http://doctrine-project.org/schemas/orm/doctrine-mapping"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://doctrine-project.org/schemas/orm/doctrine-mapping
                                 http://doctrine-project.org/schemas/orm/doctrine-mapping.xsd">
 
-                <entity name="AppBundle\Entity\Task">
+                <entity name="App\Entity\Task">
                     <!-- ... -->
                     <one-to-many field="tags" target-entity="Tag">
                         <cascade>
@@ -501,7 +501,7 @@ you will learn about next!).
     to the "adder" we created above, which is called by the form type since
     ``by_reference`` is set to ``false``::
 
-        // src/AppBundle/Entity/Task.php
+        // src/App/Entity/Task.php
 
         public function addTag(Tag $tag)
         {
@@ -517,7 +517,7 @@ you will learn about next!).
     In case of the many-to-many association, just make sure you have an appropriate
     method inside ``Tag`` that looks something like this::
 
-        // src/AppBundle/Entity/Tag.php
+        // src/App/Entity/Tag.php
 
         public function addTask(Task $task)
         {
@@ -535,7 +535,7 @@ The next step is to allow the deletion of a particular item in the collection.
 
 Start by adding the ``allow_delete`` option in the form Type::
 
-    // src/AppBundle/Form/Type/TaskType.php
+    // src/App/Form/TaskType.php
 
     // ...
     public function buildForm(FormBuilderInterface $builder, array $options)
@@ -549,7 +549,7 @@ Start by adding the ``allow_delete`` option in the form Type::
 
 Now, you need to put some code into the ``removeTag()`` method of ``Task``::
 
-    // src/AppBundle/Entity/Task.php
+    // src/App/Entity/Task.php
 
     // ...
     class Task
@@ -629,9 +629,9 @@ the relationship between the removed ``Tag`` and ``Task`` object.
     on the removed tag. This assumes that you have some ``editAction()`` which
     is handling the "update" of your Task::
 
-        // src/AppBundle/Controller/TaskController.php
+        // src/App/Controller/TaskController.php
 
-        use AppBundle\Entity\Task;
+        use App\Entity\Task;
         use Doctrine\Common\Collections\ArrayCollection;
 
         // ...

From f7c7aad3efbd5bb17bb4558689e4b690665ba029 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 15:18:03 +0200
Subject: [PATCH 11/18] Changed templates directory in code samples

---
 form/form_collections.rst | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 7af248cf4bf..e659f5b6831 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -192,7 +192,7 @@ has zero tags).
 
 .. code-block:: html+twig
 
-    {# app/Resources/views/task/new.html.twig #}
+    {# templates/task/new.html.twig #}
 
     {# ... #}
 
@@ -273,7 +273,7 @@ change to the existing ``<ul>`` in your template:
 
 .. code-block:: html+twig
 
-    {# app/Resources/views/task/new.html.twig #}
+    {# templates/task/new.html.twig #}
     
     {# ... #}
     
@@ -325,7 +325,7 @@ First, add the link somewhere in your template:
 
 .. code-block:: html+twig
 
-    {# app/Resources/views/task/new.html.twig #}
+    {# templates/task/new.html.twig #}
     
     {# ... #}
     

From 67453df3a5431e71918c174442e036d71a3b008f Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 15:21:57 +0200
Subject: [PATCH 12/18] Added routing annotation to Controller in code sample

---
 form/form_collections.rst | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index e659f5b6831..e8599b4c942 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -154,6 +154,9 @@ In your controller, you'll create a new form from the ``TaskType``::
     use Symfony\Component\HttpFoundation\Request;
     use Symfony\Bundle\FrameworkBundle\Controller\Controller;
 
+    /**
+     * @Route("/task/new")
+     */
     class TaskController extends Controller
     {
         public function newAction(Request $request)

From 4cbd26992849da415bafa1a5bf599a72262b9cc4 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 15:31:27 +0200
Subject: [PATCH 13/18] Fixing controller in code sample

---
 form/form_collections.rst | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index e8599b4c942..3d5628c3fa9 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -152,14 +152,15 @@ In your controller, you'll create a new form from the ``TaskType``::
     use App\Entity\Tag;
     use App\Form\TaskType;
     use Symfony\Component\HttpFoundation\Request;
-    use Symfony\Bundle\FrameworkBundle\Controller\Controller;
+    use Symfony\Component\Routing\Annotation\Route;
+    use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
 
-    /**
-     * @Route("/task/new")
-     */
-    class TaskController extends Controller
+    class TaskController extends AbstractController
     {
-        public function newAction(Request $request)
+        /**
+         * @Route("/task/new")
+         */
+        public function new(Request $request)
         {
             $task = new Task();
 

From fa8cbef6b9b5ccfafdee635cb7feb70ba51535a4 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 15:35:13 +0200
Subject: [PATCH 14/18] Minor

---
 form/form_collections.rst | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 3d5628c3fa9..b3ab702038d 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -199,7 +199,8 @@ has zero tags).
     {# templates/task/new.html.twig #}
 
     {# ... #}
-
+    
+    <h2>New Task</h2>
     {{ form_start(form) }}
         {# render the task's only field: description #}
         {{ form_row(form.description) }}

From f5e60c3b61ee7de1b5ae136abb0db504a5970865 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 15:54:23 +0200
Subject: [PATCH 15/18] Minor

---
 form/form_collections.rst | 19 +++----------------
 1 file changed, 3 insertions(+), 16 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index b3ab702038d..b33eeea2b35 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -273,25 +273,12 @@ add the ``allow_add`` option to your collection field::
 In addition to telling the field to accept any number of submitted objects,
 ``allow_add`` also makes a ``prototype`` variable available to you. This
 "prototype" is a little "template" that contains all the HTML needed to dynamically
-render any new "tag" forms with JavaScript. To render the prototype, make the following
-change to the existing ``<ul>`` in your template:
+render any new "tag" forms with JavaScript. To render the prototype, add the following
+``data-prototype`` attribute to the existing ``<ul>`` in your template:
 
 .. code-block:: html+twig
 
-    {# templates/task/new.html.twig #}
-    
-    {# ... #}
-    
-    {{ form_start(form) }}
-    
-        {# ... #}
-
-        <ul class="tags" data-prototype="{{ form_widget(form.tags.vars.prototype)|e('html_attr') }}">
-            {# ... #}
-        </ul>
-    {{ form_end(form) }}
-
-    {# ... #}
+    <ul class="tags" data-prototype="{{ form_widget(form.tags.vars.prototype)|e('html_attr') }}">
 
 On the rendered page, the result will look something like this:
 

From 8121e001bfa39adf9263b69da2a41482775a1028 Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 16:22:54 +0200
Subject: [PATCH 16/18] Minor

---
 form/form_collections.rst | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index b33eeea2b35..30f7ce7649d 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -30,9 +30,9 @@ by creating a simple ``Task`` class::
 
     class Task
     {
-        protected $description;
+        private $description;
 
-        protected $tags;
+        private $tags;
 
         public function __construct()
         {

From 2bb9f6b0d788f3be87573768504c1ce6ed06590e Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 16:36:17 +0200
Subject: [PATCH 17/18] Update form_collections.rst

---
 form/form_collections.rst | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 30f7ce7649d..67a7d116f8c 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -122,6 +122,7 @@ Notice that you embed a collection of ``TagType`` forms using the
     use Symfony\Component\Form\FormBuilderInterface;
     use Symfony\Component\OptionsResolver\OptionsResolver;
     use Symfony\Component\Form\Extension\Core\Type\CollectionType;
+    use Symfony\Component\Form\Extension\Core\Type\SubmitType;
 
     class TaskType extends AbstractType
     {
@@ -133,6 +134,7 @@ Notice that you embed a collection of ``TagType`` forms using the
                 'entry_type' => TagType::class,
                 'entry_options' => array('label' => false),
             ));
+            $builder->add('submit', SubmitType::class);
         }
 
         public function configureOptions(OptionsResolver $resolver)

From de554f0f5aafc306a00ec367afea29524e3f680a Mon Sep 17 00:00:00 2001
From: Thomas Landauer <thomas@landauer.at>
Date: Thu, 5 Sep 2019 16:37:23 +0200
Subject: [PATCH 18/18] Added persist to sample code

---
 form/form_collections.rst | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/form/form_collections.rst b/form/form_collections.rst
index 67a7d116f8c..3441db6e799 100644
--- a/form/form_collections.rst
+++ b/form/form_collections.rst
@@ -150,19 +150,20 @@ In your controller, you'll create a new form from the ``TaskType``::
     // src/App/Controller/TaskController.php
     namespace App\Controller;
 
-    use App\Entity\Task;
-    use App\Entity\Tag;
-    use App\Form\TaskType;
     use Symfony\Component\HttpFoundation\Request;
     use Symfony\Component\Routing\Annotation\Route;
     use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
+    use Doctrine\ORM\EntityManagerInterface;
+    use App\Entity\Task;
+    use App\Entity\Tag;
+    use App\Form\TaskType;
 
     class TaskController extends AbstractController
     {
         /**
          * @Route("/task/new")
          */
-        public function new(Request $request)
+        public function new(Request $request, EntityManagerInterface $em)
         {
             $task = new Task();
 
@@ -181,7 +182,9 @@ In your controller, you'll create a new form from the ``TaskType``::
             $form->handleRequest($request);
 
             if ($form->isSubmitted() && $form->isValid()) {
-                // ... maybe do some form processing, like saving the Task and Tag objects
+                // ... maybe do some form processing, like saving the Task and Tag objects:
+                $em->persist($task);
+                $em->flush();
             }
 
             return $this->render('task/new.html.twig', array(