mar
06
2012

par Paul

J’utilise pas mal Symfony premier du nom et je me suis dis tiens y a la v2 je vais m’y mettre.

J’attendais beaucoup et ben je suis super super déçu.
Tout me semble plus compliqué avec la v2.

Par défaut avec la v1 j’avais:

  • Tout le schema de l’application dans schema.yml
  • Les données initiales avec data/fixtures/

En quelques commandes console, j’avais une base de données crées, les données initiales chargées et les models associés créés.

Maintenant il faut que je crée (par défaut), les models à la main avec le principe de notations:

< ?php

namespace Wayr\SecurityBundle\Entity;

use Symfony\Component\Security\Core\User\UserInterface;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\Mapping as ORM;
use Symfony\Component\Security\Core\User\AdvancedUserInterface;

/**
 * Wayr\SecurityBundle\Entity\User
 *
 * @ORM\Table(name="w_users")
 * @ORM\Entity(repositoryClass="Wayr\SecurityBundle\Entity\UserRepository")
 */
class User implements AdvancedUserInterface
{

    /**
     * @ORM\Column(name="id", type="integer")
     * @ORM\Id()
     * @ORM\GeneratedValue(strategy="AUTO")
     */
    private $id;

    /**
     * @ORM\Column(name="username", type="string", length=25, unique=true)
     */
    private $username;

    /**
     * @ORM\Column(name="salt", type="string", length=40)
     */
    private $salt;

    /**
     * @ORM\Column(name="password", type="string", length=40)
     */
    private $password;

    /**
     * @ORM\Column(name="email", type="string", length=60, unique=true)
     */
    private $email;

    /**
     * @ORM\Column(name="is_active", type="boolean")
     */
    private $isActive;

    /**
     * @ORM\ManyToMany(targetEntity="Group", inversedBy="users", cascade={"remove"})
     * @ORM\JoinTable(name="w_users_groups")
     */
    private $groups;
[...]
}

Ce qui veux dire que j'ai pas mal de fichiers à crée, à nommer et à écrire juste pour avoir un schema de base de données.

Et je ne parle même pas des données initiales ... ou avant seul un simple fixtures.yml suffisait.

sfGuardPermission:
  backend:
    name: 'backend'
    description: 'Can use backend'
sfGuardGroup:
  superAdmin:
    name: 'Super Admin'
    description: 'Dieu.'
    Permissions: [ '< ?php echo implode("','", $superAdmin); ?>']
  backendUser:
    name: 'Backend User'
    description: 'Can use backend'
    Permissions: [backend]

Maintenant il faut faire je cite:

[doctrine-fixtures]
    git=http://github.com/doctrine/data-fixtures.git

[DoctrineFixturesBundle]
    git=http://github.com/symfony/DoctrineFixturesBundle.git
    target=/bundles/Symfony/Bundle/DoctrineFixturesBundle

Update the vendor libraries:
$ php bin/vendors install

If everything worked, the doctrine-fixtures library can now be found at vendor/doctrine-fixtures.
Register the Doctrine\Common\DataFixtures namespace in app/autoload.php.

// ...
$loader->registerNamespaces(array(
    // ...
    'Doctrine\\Common\\DataFixtures' => __DIR__.'/../vendor/doctrine-fixtures/lib',
    'Doctrine\\Common' => __DIR__.'/../vendor/doctrine-common/lib',
    // ...
));

Finally, register the Bundle DoctrineFixturesBundle in app/AppKernel.php.

// ...
public function registerBundles()
{
    $bundles = array(
        // ...
        new Symfony\Bundle\DoctrineFixturesBundle\DoctrineFixturesBundle(),
        // ...
    );
    // ...
}

Doctrine2 fixtures are PHP classes where you can create objects and persist them to the database. Like all classes in Symfony2, fixtures should live inside one of your application bundles.
For a bundle located at src/Acme/HelloBundle, the fixture classes should live inside src/Acme/HelloBundle/DataFixtures/ORM or src/Acme/HelloBundle/DataFixtures/MongoDB respectively for the ORM and ODM, This tutorial assumes that you are using the ORM – but fixtures can be added just as easily if you’re using the ODM.
Imagine that you have a User class, and you’d like to load one User entry:

// src/Acme/HelloBundle/DataFixtures/ORM/LoadUserData.php
namespace Acme\HelloBundle\DataFixtures\ORM;

use Doctrine\Common\DataFixtures\FixtureInterface;
use Acme\HelloBundle\Entity\User;

class LoadUserData implements FixtureInterface
{
    public function load($manager)
    {
        $userAdmin = new User();
        $userAdmin->setUsername('admin');
        $userAdmin->setPassword('test');

        $manager->persist($userAdmin);
        $manager->flush();
    }
}

In Doctrine2, fixtures are just objects where you load data by interacting with your entities as you normally do. This allows you to create the exact fixtures you need for your application.
The most serious limitation is that you cannot share objects between fixtures. Later, you’ll see how to overcome this limitation.

Ca c’est de l’évolution…

Ma dernière frustration c’est le plugin sfDoctrineGuardPlugin, qui marchait très bien, très fonctionnel, personnalisable, facile d’installation qui bien sur n’existe pas, à la place on a une documentation certes complète mais qui nous fait écrire et écrire du code pour au final quelque chose de moins bien.

A notre époque, il me semblait que le but c’était d’écrire moins de code « trivial », de réutiliser un maximum pour se concentrer que sur la logique pur et dur de l’application, avec Symfony2 non, on s’arrache les cheveux avant même de commencer…

Symfony2 se rapproche plus pour moi de la barre de fer que de la vraie boite à outil. Car je vais d’abors devoir me construire mon marteau, mon clou, ma regle, juste pour accrocher un cadre.
Alors que Symfony1 était la vrai boite à outils, quasiment complète dès le départs.