Sappiamo che Symfony2 predilige l’utilizzo di git come sistema di versionamento. Tuttavia, potrebbero esserci tutta una serie di ragioni per cui un progetto abbia bisogno di subversion: la stessa documentazione ufficiale ne fa un accenno, purtroppo senza addentrarsi nei dettagli.
Ecco qui cosa fare per avere un progetto Symfony2 funzionante con svn. Diamo per scontato di trovarci un una cartella in cui è stato fatto un checkout di un repository e in cui la cartella vendor di Symfony2 non sia presente (per esempio, perché il repository contiene uno scheletro di progetto simile a quello della Standard Edition senza venditori).
La prima cosa da fare è aggiungere i vari bundle e le altre dipendenza in externals:

mkdir vendor
svn pe svn:externals vendor

Nella finestra dell’editor, inserire le seguenti righe:

symfony              http://svn.github.com/symfony/symfony.git
twig                 http://svn.github.com/fabpot/Twig.git
monolog              http://svn.github.com/Seldaek/monolog.git
doctrine-common      http://svn.github.com/doctrine/common.git
doctrine-dbal        http://svn.github.com/doctrine/dbal.git
doctrine             http://svn.github.com/doctrine/doctrine2.git
swiftmailer          http://svn.github.com/swiftmailer/swiftmailer.git
assetic              http://svn.github.com/kriswallsmith/assetic.git
twig-extensions      http://svn.github.com/fabpot/Twig-extensions.git
metadata             http://svn.github.com/schmittjoh/metadata.git
 
doctrine-extensions  http://svn.github.com/l3pp4rd/DoctrineExtensions.git
 
bundles/Stof/DoctrineExtensionsBundle       http://svn.github.com/stof/StofDoctrineExtensionsBundle.git
 
bundles/Sensio/Bundle/FrameworkExtraBundle  http://svn.github.com/sensio/SensioFrameworkExtraBundle.git
bundles/Sensio/Bundle/DistributionBundle    http://svn.github.com/sensio/SensioDistributionBundle.git
bundles/Sensio/Bundle/GeneratorBundle       http://svn.github.com/sensio/SensioGeneratorBundle.git
bundles/JMS/SecurityExtraBundle             http://svn.github.com/schmittjoh/JMSSecurityExtraBundle.git
 
cg-library                                  http://svn.github.com/schmittjoh/cg-library.git
bundles/JMS/AopBundle                       http://svn.github.com/schmittjoh/JMSAopBundle.git
 
symfony/src/Symfony/Bundle/AsseticBundle    http://svn.github.com/symfony/AsseticBundle.git

Si noti che sono stati aggiunti, oltre ai bundle di base, alcuni altri bundle utili.
Il problema di questo approccio è che github, almeno attualmente, non supporta il checkout di tag o branch tramite svn. Per questo le versioni dei vari venditori importate saranno quelle dei rispettivi master, quindi le versioni in sviluppo. Se quindi si riscontrano errori o eccezioni dovuti per esempio a metodi mancanti, si verifichi che il file app/bootstrap.php.cache contenga tutto ciò che è necessario. Ovviamente, va adattato anche il file relativo all’autoload:

// app/autoload.php
$loader->registerNamespaces(array(
    'Symfony'          => array(__DIR__.'/../vendor/symfony/src', __DIR__.'/../vendor/bundles'),
    'Sensio'           => __DIR__.'/../vendor/bundles',
    'JMS'              => __DIR__.'/../vendor/bundles',
    'CG'               => __DIR__.'/../vendor/cg-library/src',
    'Doctrine\\Common' => __DIR__.'/../vendor/doctrine-common/lib',
    'Doctrine\\DBAL'   => __DIR__.'/../vendor/doctrine-dbal/lib',
    'Doctrine'         => __DIR__.'/../vendor/doctrine/lib',
    'Monolog'          => __DIR__.'/../vendor/monolog/src',
    'Assetic'          => __DIR__.'/../vendor/assetic/src',
    'Metadata'         => __DIR__.'/../vendor/metadata/src',
    'Gedmo'            => __DIR__.'/../vendor/doctrine-extensions/lib',
    'Stof'             => __DIR__.'/../vendor/bundles',
));

e anche quello relativo all’attivazione dei bundle:

// app/AppKernel.php
public function registerBundles()
{
    $bundles = array(
        new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
        new Symfony\Bundle\SecurityBundle\SecurityBundle(),
        new Symfony\Bundle\TwigBundle\TwigBundle(),
        new Symfony\Bundle\MonologBundle\MonologBundle(),
        new Symfony\Bundle\SwiftmailerBundle\SwiftmailerBundle(),
        new Symfony\Bundle\DoctrineBundle\DoctrineBundle(),
        new Symfony\Bundle\AsseticBundle\AsseticBundle(),
        new Sensio\Bundle\FrameworkExtraBundle\SensioFrameworkExtraBundle(),
        new JMS\AopBundle\JMSAopBundle(),
        new JMS\SecurityExtraBundle\JMSSecurityExtraBundle(),
        new Stof\DoctrineExtensionsBundle\StofDoctrineExtensionsBundle(),
    );
 
    if (in_array($this->getEnvironment(), array('dev', 'test'))) {
        $bundles[] = new Symfony\Bundle\WebProfilerBundle\WebProfilerBundle();
        $bundles[] = new Sensio\Bundle\GeneratorBundle\SensioGeneratorBundle();
    }
 
    return $bundles;
}

Aggiornamento: si può adattare facilmente app/bootstrap.php.cache con il comando

php ./vendor/bundles/Sensio/Bundle/DistributionBundle/Resources/bin/build_bootstrap.php

1
2
3
4
5
6

// funzione originale
public function pippo()
{
  parent:pippo()
  // ecc. ecc.
}

Se siamo in un caso come questo e ci serve sovrascrivere la funzione pippo(), non possiamo ricorrere a parent::, perché richiamerebbe appunto la funzione che vogliamo aggirare. La soluzione è tanto semplice quanto efficace:

1
2
3
4
5
6

// nostra funzione di override
public function pippo()
{
  call_user_func(array(get_parent_class(get_parent_class($this)), 'pippo'));
  // ecc. ecc.
}

In questo modo possiamo richiamare direttamente il nonno della nostra classe, invece del padre

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

<?php
 
/**
 * progressbar task
 *
 * PEAR's Console_ProgressBar is required.
 * If Console_ProgressBar is not installed, no bar is displayed and no error is given
 * @see http://pear.php.net/package/Console_ProgressBar
 *
 * Usage: extend this class instead of sfBaseTask in your task.
 *        in your execute() method, call $this->init() and then other methods
 *        where appropriate.
 *
 * @author  Massimiliano Arione
 */
abstract class progressbarTask extends sfBaseTask
{
  protected
    $bar,
    $hasBar = false;
 
  /**
   * initialize ProgressBar
   */
  protected function init()
  {
    $this->hasBar = @include_once 'Console/ProgressBar.php';
  }
 
  /**
   * start bar
   * @param integer $count total number of items
   */
  protected function start($count = 0)
  {
    if ($this->hasBar)
    {
      $this->bar = new Console_ProgressBar('[%bar%] %percent% %elapsed%', '=>', ' ', 90, $count);
    }
  }
 
  /**
   * update the bar
   * @param integer $step
   */
  protected function update($step)
  {
    if ($this->hasBar)
    {
      $this->bar->update($step);
    }
  }
 
  /**
   * erase the bar
   */
  protected function erase()
  {
    if ($this->hasBar)
    {
      $this->bar->erase();
      $this->log('');
    }
  }
}

L’utilizzo è molto semplice: basta richiamare il metodo init(), quindi ogni volta che serve barra di progressione richiamare start(), update() ed erase() rispettivamente prima, durante e dopo il ciclo. Al metodo update() va passato un contatore, che deve essere incrementato nel ciclo stesso.

1
2
3

login:
  url:   /login
  param: { module: default, action: login }

Inseriamo poi le credenziali dell’utente che deve accedere al backend, nel file app.yml dell’applicazione:

1
2
3
4

all:
  admin_user:     admin
  # qui conviene mettere una password migliore :-)
  admin_password: admin

Basterà quindi inserire la sequente azione nel modulo default:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

public function executeLogin(sfWebRequest $request)
{
  if ($this->getUser()->isAuthenticated())
  {
    return $this->redirect('@homepage');
  }
  if (isset($_SERVER['PHP_AUTH_USER']))
  {
    if ($_SERVER['PHP_AUTH_USER'] == sfConfig::get('app_admin_user') &&
        $_SERVER['PHP_AUTH_PW'] == sfConfig::get('app_admin_password'))
    {
      $this->getUser()->setAuthenticated(true);
 
      return $this->redirect($request->getUri());
    }
  }
  $this->getResponse()->setStatusCode(401);
  $this->getResponse()->setHttpHeader('WWW_Authenticate', 'Basic realm="Authentication required"');
 
  return sfView::NONE;
}

E il gioco è fatto. Eventualmente si può personalizzare il messaggio “Authentication required”.
Nei test funzionali, sarà possibile effettuare il login usando il metodo setAuth(), con l’accortezza di seguire il redirect dopo il primo get.

1
2
3
4
5

$browser->
  setAuth('admin', 'admin')->
  get('/')->
  with('response')->isRedirected()->followRedirect()->
 // eccetera...

In questi casi sfTesterMailer, che con il metodo withMessage(), ci viene incontro dandoci la possibilità di filtrare, filtrando per destinatario, l’email che vogliamo testare.

Supponiamo ad esempio di aver spedito due email, una a admin@example.org e l’altra ad user@example.org in questo ordine.

Il test funzionale corrispondente sarà:

1
2
3
4
5
6

with('mailer')->begin()->
  hasSent(2)->
  checkHeader('to', '/admin@example.org/')->
  withMessage('user@example.org')->
  checkHeader('to', '/user@example.org/')->
end();

Inoltre il metodo withMessage() ci permette anche di ciclare all’interno dei messaggi, usando un secondo parametro denominato $position, casomai i messaggi inviati all’utente siano più di uno.

Con il mio “pair” mattutino abbiamo quindi deciso di creare un nuovo metodo che sfruttasse il DOM di una pagina html e che potesse rimuovere la selezione di una opzione dato il nome o l’id della select e il valore dell’option.

Abbiamo aperto anche un ticket sul track di Symfony dove potete trovare il nuovo metodo e il test unitario che ne verifica la correttezza!

Buon testing a tutti!!

SELECT TYPE,COUNT(*) AS num FROM card GROUP BY TYPE;

Purtroppo con Propel la cosa non appare subito immediata. Ecco quindi un prezioso metodo da aggiungere alla vostra classe Peer per poterlo fare in modo semplice. Prima di tutto occorre inserire una nuova proprietà $count nel vostro modello (che nel mio esempio si chiama “Card”), con relativi getter e setter:

1
2
3
4
5
6
7
8
9
10
11

protected $count;
 
public function getCount()
{
  return $this->count;
}
 
public function setCount($count)
{
  $this->count = $count;
}

Ecco quindi il pezzo forte, in CardPeer (ricordate sempre che va adattato secondo il nome del vostro modello):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/**
 * grouped select
 * @param  Criteria $c
 * @param  string   $column
 * @return array
 */
public static function doSelectGroupBy(Criteria $c = null, $column)
{
  if (empty($c))
  {
    $c = new Criteria;
  }
  self::addSelectColumns($c);
  $c->addGroupByColumn($column);
  $c->addAsColumn('cnt', 'COUNT(*)');
  $stmt = self::doSelectStmt($c);
  $cards = array();
  while ($row = $stmt->fetch(PDO::FETCH_NUM))
  {
    $card = new Card;
    $col = $card->hydrate($row);
    $card->setCount(($row[$col] !== null) ? (int) $row[$col] : null);
    $cards[] = $card;
  }
  return $cards;
}

Ecco infine un esempio di utilizzo:

1

$cards = CardPeer::doSelectGroupBy(null, CardPeer::TYPE);

1
2
3
4
5

$this->widgetSchema['created_at']->setOption('template', 'da %from_date%<br /> a %to_date%');
$this->widgetSchema['created_at']->getOption('from_date')->setOption('format', '%day%/%month%/%year%');
$this->widgetSchema['created_at']->getOption('from_date')->setOption('empty_values', array('year' => 'anno', 'month' => 'mese', 'day' => 'giorno'));
$this->widgetSchema['created_at']->getOption('to_date')->setOption('format', '%day%/%month%/%year%');
$this->widgetSchema['created_at']->getOption('to_date')->setOption('empty_values', array('year' => 'anno', 'month' => 'mese', 'day' => 'giorno'));

come si può capire facilmente dal codice, non solo abbiamo messo le etichette in Italiano, ma abbiamo anche invertito l’ordine di mese e anno, portandolo nella forma che ci è più consona.
Ovviamente le opzioni viste sopra si possono applicare anche ad un eventuale campo “updated_at”, o a qualsiasi altro campo di tipo data.

Tale scelta ha però portato ad alcune mancanze, prima tra tutte l’impossibilità di definire un behavior rich per quelle form più spesso usate, una per tutte quella delle date.

Un’utile soluzione è quindi quella di includere all’interno della propria applicazione UI JQuery e nello special modo il modulo datepicker.

Supponiamo che all’interno della classe che definisce la form del nostro modello esista un widget definito come sfWidgetFormDateTime(). Per sostituire alla scomoda select multipla un calendario javascript dovremmo così agire:

1
2
3
4
5
6
7
8

class EventForm extends BaseEventForm
{
  public function configure()
  {    
    $this->widgetSchema['date'] = new sfWidgetFormInput();
    $this->validatorSchema['date'] = new sfValidatorDateTime( array('with_time' => false) );    
   }
}

definiamo quindi la vista che mostrerà la nostra form (supponendo di includere nel layout della nostra applicazione jquery.js e ui.js.

1
2
3
4
5
6
7
8
9

<style type="text/css">.embed + img { position: relative; left: -21px; top: -1px; }</style>
<script type="text/javascript">
$("#event_date").datepicker({ 
    showOn: "button", 
    buttonImage: "/web/images/calendar.gif", 
    buttonImageOnly: true 
}).addClass("embed");
</script>
<?php echo $form; ?>

et voilà: un bellissimo calendario javascript tornerà a rendere “felici” le nostre applicazioni web 2.0

Per ovviare a questo inconveniente, nell’attesa che il ticket sia chiuso, si può usare questo escamotage. Creare una classe, per esempio /lib/fixAmp.class.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

<?php
class fixAmp
{
  /**
   * fix ampersands in HTML strings
   * @param  string $txt
   * @return string
   */
  public static function fixAmps($txt)
  {
    $txt = mb_eregi_replace('&amp;(?!amp;)', '&amp;', $txt);
    $txt = mb_eregi_replace('&amp;#(\d+);', '&#\1;', $txt);  // for numeric entities
    $txt = mb_eregi_replace('&amp;(\w+);', '&\1;', $txt);  // for literal entities
    $txt = mb_eregi_replace('&amp;&amp;', '&&', $txt);  // for php boolean control
    return $txt;
  }
}
?>

Quindi nella action basterà applicare il metodo al testo ottenuto dalla textarea.
Ad esempio

1

$myClass->setContent(fixAmps::fixAmps($this->getRequestParameter('content')));

La classe vista sopra utilizza mb_eregi_replace() per poter funzionare con i caratteri multi-byte, ma si può facilmente modificare per l’utilizzo con preg_replace()