Rilasciati Symfony 3.4 e Symfony 4.0

Esattamente otto anni fa uscirono Symfony 1.3 e 1.4. È curioso vedere come già a quei tempi ci fossero quegli elementi che ormai caratterizzano Symfony da tempo, come un preciso calendario di rilasci e un’oculata strategia di deprecati e cambi di versione. È un po’ un peccato che l’articolo si limiti a riportare dei link, purtroppo ormai morti.
Ieri, ora come allora, c’è stato l’importante rilascio della versione maggiore 4.0 e della gemella 3.4 (LTS). Rilascio importante, perché foriero di tre importanti novità:

  • una struttura di cartelle rinnovata e più standard
  • un nuovo sistema di gestione delle dipendenze, molto più flessibile e facile da usare
  • l’autowiring del container, che consente di concentrarsi più sul codice e pensare meno alle configurazioni dei servizi
    • Ovviamente ci sono tante altre aggiunte e migliorie, per cui si rimanda al blog ufficiale (sperando che tra altri otto anni il link sia ancora lì)

    Symfony 2.7 e PSR-7

    Da pochissime ore è stato annunciato il rilascio della versione 2.7 di Symfony, che sarà una versione a supporto pronlungato (nota anche come LTS). Questa versione punta a essere un punto di passaggio per la prossima versione maggiore, ovvero Symfony3, con molte funzionalità che sono state deprecate rispetto alle versioni precedenti.
    Una sorpresa contenuta in questa versione è il supporto al nuovissimo PSR-7, per cui sarà da subito possibile utilizzare le classi standard di tale PSR, ma anche convertire facilmente le attuali Request e Response di Symfony nelle rispettive Request e Response della PSR.
    In contemporanea, dovrebbe essere uscita anche la versione 2.8, che sarà a sua volta LTS e identica alla 2.7, tranne per le funzionalità deprecate, qui rimosse. Questa versione quindi dovrebbe essere l’ultimo passaggio verso la 3.0, ma al momento nessun annuncio è ancora stato pubblicato. Inoltre, non è ancora disponibile un percorso di aggiornamento tra le uniche due versioni LTS attualmente disponibili, cioè la 2.3 e la 2.7. Restiamo in attesa di chiarimenti.

    È uscito Symfony 2.5

    Con pochi giorni di ritardo rispetto alla data prevista, è uscito la settimana scorsa Symfony 2.5.
    Non ci sono novità eclatanti in questa versione, ma molti piccoli affinamenti e alcuni strumenti utili in più rispetto alla precedente versione. In compenso, aggiornare è relativamente semplice e non richiede nemmeno una modifica di composer.json (questa feature era stata pensata in questo modo nella 2.4, per questo il requisito presente era, ed è tuttora, ~2.4): basta dunque eseguire composer update.
    Ci sono alcune incompatibilità minori, soprattutto per quanto riguarda la validazione con i form: rimandiamo al file UPGRADE-2.5.md per i dettagli.

    Symfony 2.3 LTS

    Ieri sul blog ufficiale è stato annunciato il rilascio della prima versione a supporto prolungato (in gergo, LTS) di Symfony2. Questa versione dunque sarà supportata per ben tre anni, fino al 2016, e costituirà quindi una prima pietra miliare su cui basare i propri progetti a lungo termine.
    Per tutti i dettagli su changelog e update rimandiamo al post del blog già linkato, qui ricordiamo che aggiornare dalla 2.2 viene indicato come “indolore” (“painless”), come d’altronde era stato anche per l’aggiornamento precedente, segnando quindi un arco di continuità dalla versione 2.1, che è stato il primo vero rilascio dirompente.

    Fixture con contenitore di servizi nei test funzionali

    A volte può essere utile avere a disposizione il contenitore di servizi nelle fixture usate nei test funzionali. Un caso tipico è l’uso di FOSUserBundle, che mette a disposizione un servizio UserManager per creare utenti, utilizzabile quindi anche per crearli all’interno delle fixture.
    Purtroppo la documentazione a riguardo è alquanto avara di informazioni, per cui condivido qui questa soluzione, mostrando un esempio.
    Ecco un possibile file di fixture per gli utenti:

    <?php
     
    namespace Acme\PippoBundle\DataFixtures\ORM;
     
     
    use Doctrine\Common\DataFixtures\AbstractFixture;
    use Doctrine\Common\DataFixtures\OrderedFixtureInterface;
    use Doctrine\Common\Persistence\ObjectManager;
    use Symfony\Component\DependencyInjection\ContainerAwareInterface;
    use Symfony\Component\DependencyInjection\ContainerInterface;
     
    class LoadUserData extends AbstractFixture implements OrderedFixtureInterface, ContainerAwareInterface
    {
        private $container;
     
        public function setContainer(ContainerInterface $container = null)
        {
            $this->container = $container;
        }
     
        public function load(ObjectManager $manager)
        {
            $userManager = $this->container->get('fos_user.user_manager');
     
            $user1 = $userManager->createUser();
            $user1
                ->setUsername('pippo')
                ->setEmail('pippo@example.org')
                ->setFirstName('Mallo')
                ->setLastName('Di Noce')
                ->setBirthday(new \DateTime('1977-07-07'))
                ->setEnabled(true)
                ->setPlainPassword('mallodinoce')
            ;
            $userManager->updateUser($user1, false);
            $manager->persist($user1);
            $this->addReference('user1', $user1);
     
            $manager->flush();
        }
     
        public function getOrder()
        {
            return 1;
        }
    }

    Questa fixture si può usare in un test in questo modo:

    <?php
     
    namespace Acme\PippoBundle\Tests\Controller;
     
    use Acme\PippoBundle\DataFixtures\ORM\LoadUserData;
    use Doctrine\Common\DataFixtures\Executor\ORMExecutor;
    use Doctrine\Common\DataFixtures\Purger\ORMPurger;
    use Symfony\Bridge\Doctrine\DataFixtures\ContainerAwareLoader as Loader; // il trucco è qui..
    use Symfony\Bundle\FrameworkBundle\Test\WebTestCase
     
    class DefaultControllerTest extends WebTestCase
    {
        public function setUp()
        {
            $kernel = static::createKernel();
            $kernel->boot();
            $container = $kernel->getContainer();
            $loader = new Loader($container);  // ... e qui
            $loader->addFixture(new LoadUserData);
            $purger = new ORMPurger();
            $executor = new ORMExecutor($this->em, $purger);
            $executor->execute($loader->getFixtures());
        } 
     
        public function testIndex()
        {
            $client = static::createClient();
            $crawler = $client->request('GET', '/');
            $this->assertTrue($client->getResponse()->isSuccessful());
        }
    }