Controller.php

<?php

    protected function _editAction(Post $post)
    {
        $em = $this->get('doctrine.orm.default_entity_manager');
        $factory = $this->get('form.factory');
        $form = $factory->create(new PostFormType());
        $form->setData($post);

        if ($this->get('request')->getMethod() === 'POST') {
            $form->bindRequest($this->get('request'));

            if ($form->isValid()) {
                $em->persist($post);
                $em->flush();

                return new RedirectResponse($this->generateUrl('hello_index'));
            }
        }

        return $this->render('MyHelloBundle:Hello:edit.html.twig', array(
            'form' => $form->createView(),
        ));
    }

PostFormType.php

<?php

namespace My\HelloBundle\Form;

use Symfony\Component\Form\FormBuilder;
use Symfony\Component\Form\Type\AbstractType;
use My\HelloBundle\Entity\Comment;

class PostFormType extends AbstractType
{
    public function buildForm(FormBuilder $builder, array $options)
    {
        $builder
            ->add('title')
            ->add('file')
            ->add('content')
            ->add('abstract')
            ->add('enabled')
            ->add('publicationDateStart', 'date')
            ->add('commentsDefaultStatus', 'choice', array(
                'choices' => Comment::getStatusCodes(),
            ))
            // the second parameter, $type, is null because we use auto-creation
            ->add('tags', null, array(
                'expanded' => true,
                'multiple' => true,
            ))
            ->build('author', 'form', array('data_class' => 'My\HelloBundle\Entity\Author'))
                ->add('firstName')
                ->add('lastName')
            ->end();
    }

    public function getDefaultOptions(array $options)
    {
        return array(
            'data_class' => 'My\HelloBundle\Entity\Post',
        );
    }

    public function getName()
    {
        return 'postform';
    }
}

template.html.twig

{% form_theme form _self %}
{{ form_enctype(form) }}
{{ form_widget(form) }}
{{ form_widget(form.firstName) }}

{% for child in form %}
    {{ form_widget(child) }}
{% endfor %}

{{ form_widget(form.firstName, { 'attr': { 'class': 'foobar' } }) }}
{{ form_label(form.firstName, 'My label') }}

Done

I though symfony2 was all about removing the magic?

You can provide the type and options explicitely for every field, if you want. This short syntax is meant for not duplicating logic.

Say, you store a property as datetime with constraint notnull. Symfony already knows that you (most probably) want a required date field, wo why duplicate its definition here?

That part of magic is, of course, ok, but when you explicitly specify a field type, how does it work behind the scene? I've not read the code but I imagine the date in ->add('publicationDateStart', 'date') gets inflected to some class name?

You see the getName() method in the PostFormType class? Every type has a name which is used to retrieve that type from the DIC (or wherever types are instantiated). So in your case the type with the name "date" (which is DateType) is used to configure the added field.

You can also explicitely pass the type object

->add('publicationDateStart', new DateType(...))

but then you need to know all constructor arguments of all types and get them from somewhere. By passing the name the DIC can do that for you.

I've fork AcmePizzaBundle you can take a look here, https://github.com/brikou/AcmePizzaBundle, I've tried to improve/correct this bundle, take a look and give me feedbak ;)

@bschussek Can you update your gist with latest usage, because it is obscure to me (this way I'll update the AcmeDemoBundle) ;) thx

@brikou: Done.

@bschussek great thx

What does this do exactly?

->build('author', 'form', array('data_class' => 'My\HelloBundle\Entity\Author'))

Is that a subform that creates a new author object for every post? Does that make sense?

Just trying to follow it through (:

@boutell: It embeds a new FormBuilder and immediately lets you configure it. So

$builder->build('author', 'form')
    ->add('firstName', 'text')
    ->add('lastName', 'text)
->end()

is a shorthand notation for

$authorBuilder = $factory->createBuilder('form', 'author')
    ->add('firstName', 'text')
    ->add('lastName', 'text);

$builder->add($authorBuilder);

Can you think of a more intuitive naming for build()?

addEmbedded or something along this lines?

embed :) or maybe include (also longer but IMO more intuitive: embedForm/includeForm).

So what you get is a brand new author object every time? Or is there some connection to a relation that I'm missing?

On Fri, Apr 15, 2011 at 11:50 AM, beberlei ***@***.*** wrote: addEmbedded or something along this lines? ## Reply to this email directly or view it on GitHub: https://gist.github.com/883293

## Tom Boutell P'unk Avenue 215 755 1330 punkave.com window.punkave.com

@boutell: You get a new FormBuilder object with the name "author", as in the above code snippet.

OK, I'm lost then, because I don't know what that means in terms of what objects are going to get created if any. There's an entity manager here, I'm guessing there are doctrine entities here, I'm asking if there are any relationships between these things or if we've just merged two forms. You are putting an author form into a post form, and my first thought is "that doesn't make sense, authors have multiple posts, it's not a one to one relationship so I don't understand your example and what it's meant to demonstrate"

On Fri, Apr 15, 2011 at 2:54 PM, bschussek ***@***.*** wrote: @boutell: You get a new `FormBuilder` object with the name "author", as in the above code snippet. ## Reply to this email directly or view it on GitHub: https://gist.github.com/883293

## Tom Boutell P'unk Avenue 215 755 1330 punkave.com window.punkave.com

Hehe, ok :) We're not dealing with Doctrine2 in any way here. We're just embedding a form into another. You're right that editing the data of an author within a post form does not make much sense - it was merely an example.

Long story short, you end up with a post form with lots of fields and an embedded form "author" with the fields "firstName" and "lastName". Does that make it clearer?

Yes, it does. And if there was a one-to-one relationship between two entities, it could make sense to do that. Thanks for the clarification.

On Fri, Apr 15, 2011 at 3:22 PM, bschussek ***@***.*** wrote: Hehe, ok :) We're not dealing with Doctrine2 in any way here. We're just embedding a form into another. You're right that editing the data of an author within a post form does not make much sense - it was merely an example. Long story short, you end up with a post form with lots of fields and an embedded form "author" with the fields "firstName" and "lastName". Does that make it clearer? ## Reply to this email directly or view it on GitHub: https://gist.github.com/883293

## Tom Boutell P'unk Avenue 215 755 1330 punkave.com window.punkave.com

Looking good...
Though I would prefer if data_class was extracted in the form via get_class() seems weird to ask the user about it...
Just my 2cents

@marijn: Unfortunately that's not possible. First of all, your application might provide invalid data of a wrong class or a non-object. Second, in many cases a form doesn't even have an object (think "create" forms), and we still want to be able to guess the types for those. In the above example, what if the $author property of the post is empty?

Well I think the API would be simpler if we would require to inject empty objects in that case...

For example

$form = $factory->create(new PostFormType());
$form->setData(new Post());

Though I'm not sure how that would work out for forms based on arrays...
Those should provide a static method for validation right? So we wouldn't need the class name in that case...

Maybe I'm missing the point here but I'm not convinced of the design requirement of the data_class option...

@marijn: In such a case you would also have to manually prefill the relations of an object, if you use embedded forms.

$post = new Post();
if (!$post->author) {
    $post->author = new Author();
}
if (!$post->author->address) {
    $post->author->address = new Address();
}
$form->setData($post);

You could avoid this mess by setting the empty data option:

class MyEmailType
{
    public function getDefaultOptions()
    {
        return array(
            // can also be a plain object
            'empty_data' => function (FormInterface $form) {
                return new Email(...);
            }
        );
    }
}

But then we have the problem that we need to invoke this closure already when building the form in order to find out the type of the created object, which we can't, because we don't have a FormInterface object yet, only a FormBuilder.

Thanks for clearing that up, it's making sense to me now :-)

How do you handle something kind like EntityChoiceList ? do I have to create my "choices" option array manually ?

@docteurklein Care to elaborate your question?

Sorry if misunderstood :)

I want my form to display a select box corresponding to all the elements of a mongo database collection.
For that, I get an array of Documents and pass it to my choice type via the choices options.

the problem is that the dataTransformer attached to the choice type is a ScalarToChoiceTransformer and it can't handle Object transformation.

FormType:

        $builder->add('frontend_template', 'choice', array(
            'choices' => $this->getTemplateChoices() // this is an array containing Objects
        ))

I finally implemented my own DataTransformer and replaced the Scalar one.

Here is how I did:

$builder->get('frontend_template')->resetClientTransformers();
$builder->get('frontend_template')->appendClientTransformer(new DocumentToChoiceTransformer($this->dm, 'Test\Document\Template'));

Transformer:

<?php

namespace Test\BlockBundle\Form;

use Doctrine\ODM\MongoDB\DocumentManager;

use Symfony\Component\Form\DataTransformerInterface;
use Test\Form\ToIdTransformable;

class DocumentToChoiceTransformer implements DataTransformerInterface
{
    private $dm;
    private $className;

    public function __construct(DocumentManager $dm, $className) 
    {
        $this->dm = $dm;
        $this->className = $className;
    }

    public function transform($value)
    {
        if(null === $value) {

            return '';
        }

        if(is_scalar($value)) {
            return $this->dm->getRepository($this->className)->find($value);
        }

        if( ! $value instanceof ToIdTransformable) {
            throw new \InvalidArgumentException(sprintf('Object must implement "ToIdTransformable" interface'));
        }

        return $value->getId();
    }

    public function reverseTransform($value)
    {
        if(is_scalar($value)) {
            return $this->dm->getRepository($this->className)->find($value);
        }
    }
}

very helpful! thanks

I forgot to say that your domain objects must implement the ToIdTransformable interface:

interface ToIdTransformable
{
    function getId();
}

But I really would like to have the thoughts of @bschussek on this :)