I have created a news aggregator and needed to paginate the results. I had the ‘feed’ object having an array of ‘feeditems’ objects in my actions. So, I could not use sfPropelPager as it needs a criteria object to pull objects from the database. The solution which worked for me is presented here. Disclaimer: This is a complete rip-off from the snippets section on symfony site, modified slightly to work with the latest version of symfony and php. I will add another post to paginate in sfFeed2Plugin when I have time.

Add this class to lib/helper or anywhere in lib and include it in the file you need to use pagination.

myArrayPager.class.php

<?php
class myArrayPager extends sfPager
{
protected $resultsArray = null;

public function __construct($class = null, $maxPerPage = 10)
{
parent::__construct($class, $maxPerPage);
}

public function init()
{
$this->setNbResults(count($this->resultsArray));

if (($this->getPage() == 0 || $this->getMaxPerPage() == 0))
{
$this->setLastPage(0);
} else {
$this->setLastPage(ceil($this->getNbResults() / $this->getMaxPerPage()));
}
}

public function setResultArray($array)
{
$this->resultsArray = $array;
}

public function getResultArray()
{
return $this->resultsArray;
}

public function retrieveObject($offset) {
return $this->resultsArray[$offset];
}

public function getResults()
{
return array_slice($this->resultsArray, ($this->getPage() – 1) * $this->getMaxPerPage(), $this->maxPerPage);
}
}
?>

In the action, instead of setting an object holding array of items, set the pager.

$empager = new myArrayPager(null, 10); //10 items per page
$empager->setResultArray($this->feed->getItems()); //my object is ‘feed’ which has ‘items’ array
$empager->setPage($request->getParameter(‘page’, 1));
$empager->init();

$this->pager = $empager;

Implementation of view is exactly the same as with sfPropelPager or the equivalent doctrine pager.

Enjoy!

I came across this situation when using sfFeed2Plugin to create a news aggregater. I had an array of feed objects and I needed to show the paginated results. Since I did not have any criteria object, I could not use sfPropelPager. This is what worked for me.

First copy the following class – myArrayPager.class.php to your lib/helper folder. This file is a direct rip-off from the snippets section of symfony.

setNbResults(count($this->resultsArray));

if (($this->getPage() == 0 || $this->getMaxPerPage() == 0))
{
$this->setLastPage(0);
}
else
{
$this->setLastPage(ceil($this->getNbResults() / $this->getMaxPerPage()));
}
}

public function setResultArray($array)
{
$this->resultsArray = $array;
}

public function getResultArray()
{
return $this->resultsArray;
}

public function retrieveObject($offset) {
return $this->resultsArray[$offset];
}

public function getResults()
{
return array_slice($this->resultsArray, ($this->getPage() – 1) * $this->getMaxPerPage(), $this->maxPerPage);
}

}
?>

Let’s assume we have the following array to paginate:

$myArray = //array of feeds or any array like array(‘the first element’, ‘the second element’,'third one’, ‘fourth one’, ‘last one’);

In your action method, add the following lines to create and initiate the pager object:

$empager = new myArrayPager(null, sfConfig::get(‘app_max_news_per_page’)); //max_news_per_page
//needs to be defined in app.yml of the module
$empager->setResultArray($myArray);
$empager->setPage($request->getParameter(‘page’, 1));
$empager->init();
$this->pager = $empager;

Note, variable myArray is set to the ResultArray of the pager. Any array can be assigned to myArray.

The view – showSuccess.php (assuming my action method is executeShow):

and the two partials:

_newslist.php

getResults() as $item): ?>

getTitle()), 100), $item->getLink()) ?>
getPubDate(), “EEE d MMMM yyyy”) ?>
| Source: getFeed()->getTitle(), $item->getFeed()->getLink()) ?>

_paginate.php

haveToPaginate()): ?>

Pagination is generic and can be used in any code requiring pagination. Also, _newslist.php uses sfFeed2Plugin and sfWebBrowser plugins.

Como primera aproximación a un buscador simple en la primera versión de Voota, se nos ocurrió utilizar “Google custom search“. Mala idea. Hoy, 5 días después de la puesta online, Google solo ha indexado 267 páginas y teniendo en cuenta que empezábamos con 1.549 políticos con sus 1.549 correspondientes fichas, los resultados no eran muy apropiados. Por ejemplo, buscando “Zapatero” aparecían varios resultados del blog, alguna ficha de otros políticos y varios enlaces al ranking, pero no la ficha del sr. presidente.

Necesitábamos un buscador, sencillo, potente y que escalase bien con los futuros desarrollos que vienen. La solución fue mucho más fácil de lo esperado. Decidimos implementar nuestro propio motor de búsqueda con Sphinx. Así es como lo hicimos:

1. Lo primero es instalar el motor de búsqueda, que básicamente consta de dos partes: El indexador, que obtiene las palabras clave de la base de datos (Postgresql o mysql) y el demonio o servicio de búsqueda que atiende a las peticiones del servidor web.
   La instalación no tiene más misterio que seguir los pasos que explican en su web: Manual de referencia de Sphinx.
2. Después viene la fase de configuración. Aquí es donde se le dice a Sphinx que datos tiene que indexar para que puedan ser encontrados en el buscador del sitio web. En nuestro caso, de momento, sólo queríamos indexar los políticos:
   source src1
   {
   type                                    = mysql
   sql_host                                = localhost
   sql_user                                = usuario
   sql_pass                                =
   sql_db                                  = voota
   sql_port                                = 3306  # optional, default is 3306
   sql_query_pre   = SET NAMES utf8
   sql_query                               = \
   SELECT id, vanity, alias, nombre, apellidos, bio, presentacion, residencia, formacion \
   FROM politico
   sql_ranged_throttle     = 0
   sql_query_info          = SELECT * FROM politico WHERE id=$id
   }
   source src1throttled : src1
   {
   sql_ranged_throttle                     = 100
   }
   index politico
   {
   source                  = src1
   path                    = /var/data/voota
   docinfo                 = extern
   mlock                   = 0
   morphology              = none
   min_word_len            = 1
   charset_type            = utf-8
   charset_table   = 0..9, A..Z->a..z, a..z, \
   U+C0->a, U+C1->a, U+C2->a, U+C3->a, \
   U+C4->a, U+C5->a, U+C6->a, \
   U+C7->c,U+E7->c, U+C8->e, U+C9->e, \
   U+CA->e, U+CB->e, U+CC->i, \
   U+CD->i, U+CE->i, U+CF->i, U+D0->d, \
   U+D1->n, U+D2->o, U+D3->o, \
   U+D4->o, U+D5->o, U+D6->o, U+D8->o, \
   U+D9->u, U+DA->u, U+DB->u, \
   U+DC->u, U+DD->y, U+DE->t, U+DF->s, \
   U+E0->a, U+E1->a, U+E2->a, U+E3->a, \
   U+E4->a, U+E5->a, U+E6->a, \
   U+E7->c,U+E7->c, U+E8->e, \
   U+E9->e, U+EA->e, U+EB->e, U+EC->i, \
   U+ED->i, U+EE->i, U+EF->i, \
   U+F0->d, U+F1->n, U+F2->o, U+F3->o, \
   U+F4->o, U+F5->o, U+F6->o, \
   U+F8->o, U+F9->u, U+FA->u, U+FB->u, \
   U+FC->u, U+FD->y, U+FE->t, U+FF->s,
   html_strip                              = 0
   }

   Extracto del fichero de configuración de Sphinx

3. A continuación se arranca el servicio de búsqueda:
   sudo searchd –config /usr/local/etc/sphinx.conf
   y se da la orden para que Sphinx realice la indexación (Esto será necesario hacerlo periódicamente):
   sudo /usr/local/bin/indexer politico –rotate
   Muy bien, Sphinx configurado y escuchando.
4. Sólo falta escribir el código Symfony para interrogar al motor de búsqueda:
   $this->q = $request->getParameter(“q”);$cl = new SphinxClient ();
   $cl->SetServer ( ‘localhost’, 3312 );
   $this->limit = 1000;
   $cl->SetLimits ( 0, $this->limit, $this->limit );
   $cl->SetArrayResult ( true );
   $this->res = $cl->Query ( SfVoUtil::stripAccents( $this->q ), ‘politico’ );
   if ( $this->res!==false ) {
   if ( isset($this->res["matches"]) && is_array($this->res["matches"]) ) {
   $c = new Criteria();
   $list = array();
   foreach ($this->res["matches"] as $idx => $match) {
   $list[] = $match['id'];
   }
   $c->add(PoliticoPeer::ID, $list, Criteria::IN);
   $c->addDescendingOrderByColumn(PoliticoPeer::SUMU);
   $this->politicosPager = new sfPropelPager(‘Politico’, 10);
   $this->politicosPager->setCriteria($c);
   $this->politicosPager->setPage($this->getRequestParameter(‘page’, 1));
   $this->politicosPager->init();if ($this->politicosPager->getNbResults() == 1){
   $res = $this->politicosPager->getResults();
   $this->redirect( “@politico_”.$this->getUser()->getCulture( ‘es’ ).”?id=”.$res[0]->getVanity() );
   }
   }
   }

   Código Symfony que realiza la búsqueda

Listo, hoy puedes buscar Zapatero, José Luis Rodriguez o ZP en Voota, que seguro que encuentras lo que buscas, a no ser que quieras comprarte unos zapatos nuevos, claro

Vous avez créé votre modèle et souhaitez tout régénérer ?
Pas de soucis vous lancez :

symfony doctrine:build-all-reload –no-confirmation

et là …

Task “doctrine:build-all-reload” is not defined.

Pas de soucis !…
doctrine:build-all-reload est maintenant déprécié; il faut saisir :

symfony doctrine:build –all ou symfony doctrine:build –all –and-load

Et ça roule !

Durante el desarrollo de nuestro proyecto para la Feria de Software tuvimos que tener algunos datos de prueba para las comunas y ciudades de Chile, como no era fundamental tener las regiones simplificamos el modelo propuesto en este sitio al siguiente (escrito en notación YAML)

Para las ciudades:

  ciudad:
   id: ~
   nombre:      { type: varchar(100) }

Para las comunas

  comuna:
   id: ~
   nombre:      { type: varchar(100) }
   ciudad_id:   { type: integer, foreignTable: ciudad, foreignReference: id, onDelete: restrict }

Los cuales, como es de presumir, fueron agregados a nuestro esquema (./config/schema.yml). Hasta aquí nada muy interesante, pero mientas discutíamos la forma más compleja y por ende mejor ( xD ) de cargar los datos,  Camila Maldonado se tomó la ‘molestia’ de pasar la información directamente a un par de archivos yaml para ser cargados como fixtures (./data/fixtures) en nuestro proyecto. Les dejo a continuación los archivos:

Descarga: Fixtures symfony – Ciudades y Comunas de Chile (zip – 5,5 KB)

Es muy posible que falten varias comunas, pero como comenté sólo necesitábamos datos de prueba y éstos se ajustaron bastante bien: 52 ciudades y 345 comunas no está mal

Catetan dikit,

In aceasta perioada trec printr-un stagiu de acomodare cu frameworkul Symfony, iar primele impresii nu sunt deloc placute.

Primul lucru peste care dai indata ce incepi sa studiezi Symfonyul este modul in care acesta stocheaza setarile, si anume in format YAML. Acest lucru prezinta overhead in citirea configurarilor, si nu pot intelege de ce fisiere de configurare PHP nu sunt de ajuns. Overheadul nu pot zice cat este de mare, dar nevoia de a invata modul de folosire al YAML in cadrul Symfony e mult mai putin decat intuitiv. Asta nu in cazul celor evidente, pe cat in cazul definirii structurilor tabelelor (si nici in documentatie nu am gasit exact cum sa descriu anumite coloane de sql, a trebuit sa recurg la google pentru asta).

Daca ziceam ca se foloseste intensiv YAML, nu va speriati, aveti la dispozitie si XML, doar pentru definirea tabelelor. Si ca suntem cu vorba la definirea tabelelor, sa stiti ca acel YAML/XML este convertit in syntaxa SQL si rulat. Asta e cu siguranta cel mai bun lucru pe care l-au putut realiza.

Un alt aspect care din fazele incipiente pare “enervant” consta in trecerea constanta la console si la rularea unor serii de comenzi pentru fiecare modul, modificare db, configurare in parte. Si sa nu uitam de modul dezordonat in care parametrii acestuia se prezinta; pentru unele optiuni avand variante scurte, iar pentru majoritatea nu.

SVN aruncat de umplutura in documentatie.

Ce este Criteria()? Da, stiu ca este folosit pentru criterile de cautare in baza de date, dar in documentatie nu apare.

Modelul MVC implementat e supra-gandit. Sapte fisiere pentru generarea de pagini. Se vede ca sistemul de templateting a fost gandit de programatori mai vechi. Si termenii sunt aiurea: layout, template, fragment. Unde parca template nu e acelasi lucru cu fragment.

Tranzactiile sunt database independent, adica sunt facute din partea de PHP. Poate doar mie mi se pare acest lucru ciudat. De asemenea frameworkul e gandit astfel ca el la treceri db sa fie functional fara modificari de setari la db. Si acum ma gandesc, la un proiect de cate ori schimbi baza de date? Cel mai probabil niciodata.

Helperul de formuri nu mi se pare atat de bine gandit, precum nici validarea. Din nou YAML, in loc sa foloseasca un model precum cel de la CodeIgniter (desigur si el ar putea fi imbunatatit, dar e un pas spre bine).

Folosinta excesiva de setter/getter pattern devine enervanta la un moment dat mai ales datorita numelor foarte lungi ale metodelor.

$this->getRequest()->getParameterHolder()->get($name)
// si varianta "scurta"
$this->getRequestParameter($name)

Pana acum nu a fost o experienta foarte placuta, iar aceste ganduri “negre” mi s-au format dupa doar o zi de utilizare. Poate a fost scris putin in graba caci vroiam sa zic cele enumerate inainte sa imi iasa din minte.

Cat despre cele placute in framework, singurul lucru care ma atras a fost scaffoldingul pus la dispozitie, eficace si simplu.

Cat despre faptul ca tutorialele acestora merg pe metodologia XP (Extreme Programming) nu a putut sa faca altceva decat sa ma irite si mai tare. Scrie intai, regandeste dupa.

Pana acum, doar eficace nu e termenul care sa imi vina in minte cand ma gandesc la Symfony.

Utilizando la clase para validar RUT que mostré en esta entrada cree un sencillo validador de RUT para los formulario de symfony 1.2

Por convención he creado la clase sfValidatorRut.class.php en el directorio /lib de la raíz del proyecto. Aquí está el código de esta clase:

<?php
/**
 * Validador de RUT para symfony 1.2
 *
 * @author Esteban Martini Muñoz
 * @version 1.0
 */
require_once dirname(__FILE__).'/../Rut.class.php';
class sfValidatorRut extends sfValidatorString
{
  public function configure ($options = array(), $messages = array())
  {
    $this->addMessage('invalid', 'El formato del RUT: %value% no es válido.');
    $this->addMessage('bad_dv', 'El dígito verificador del RUT es incorrecto.');
    $this->addMessage('required', 'RUT es requerido.');
  }
  public function doClean($value)
  {
      $clean = ltrim(rtrim(($value)));
      $rut = new Rut();
      if (!$rut->verificaFormatoRut($value))
        throw new sfValidatorError($this, 'invalid', array('value' => $value));
      else if(!$rut->isRut($value))
        throw new sfValidatorError($this, 'bad_dv', array('value' => $rut->getDV($value)));
      return (string)$rut->formatoUser($value);
  }
}

Su uso es igual al resto de los validadores de symfony sólo basta asignar el tipo de validación al campo a verificar de nuestro formulario.

//...
public function configure()
{
  $this->validatorSchema['rut_usuario'] = new sfValidatorRut();
}
//...

Espero les sea de utilidad.

Jangan tanya gw tentang deskripsi formalnya. Gw penulis code yang berasaskan best practice dengan konsep seperlunya. Ketika koding sudah efektif dari segi algoritma, memori, dan run time nya, maka cukup sudah. Coding lama2  menyebabkan penggunaan dosis caffein dan nikotin meningkat.  Gak Sehat. *malah curhat*

Jadi, setelah cukup lama membangun aplikasi web deingan  Code Igniter (CI), sekarang gw dilibatkan dengan aplikasi yang  menggunakan php framework Symfony. Seberapa jauh bedanya??? beda banged.

Symfony dikembangkan sampe versi 1.3 . Beda ama CI yang sekarang udah ampe 1.7. Bukan berarti Symfony ga da perkembangan, ato kurang komunitasnya. Justru sejak awal dibangun, Symfony udah sangat direncanakan dengan konsep yang matang. Jadi, baik frameworknya, dokumentasinya,  dan  dukungan third party libraries-nya bisa dibilang lengkap dan stabil.

What next? pertamakali, cari tahu makhluk apa ini di site resminya : http://www.symfony-project.org/ .  Learning curve-nya lumayan berat, so just move on, slowly but sure.

Fundamental things that you have to know sebelum akhirnya masuk lebih jauh ke symfony, ga perlu tau detil,  setidaknya cukup mengenal, antara lain :

1. PHP 5.  Symfony dibangun diatas PHP 5. Dapat dipastikan berbau bau object, class, dsb.

2. OOP. Relasinya jelas dari point 1. Akan lebih sering menulis  code “tanda panah” disini

3. ORM (Object Relational Mapping). Singkat kata, ini merupakan metode pemetaan objek database menjadi objek class, sehingga kelak apapun database yg digunakan, ga jadi masalah. Dalam hal ini, ORM yang digunakan bisa Propel, atau Doctrine.

4. YAML. Semacam XML but with a much simpler syntax. Scripting language yang vital dan banyak ditemukan di symfony. Script ini nantinya akan meng’generate’/parsing menjadi script php yang gak perlu lagi dicoding oleh programmernya.

5. MVC Pattern. Model, View, Controller. Bla bla bla

Ada yang bilang, framework symfony adalah awalan yang baik untuk belajar framework di PHP. Kenapa? ga tau juga, gw baru mulai. Mungkin karena saking kompleksnya framework ini, sehingga kalo ini dikuasai, maka penguasaan framework lain akan lebih mudah. Setidaknya sebelumnya gw udah buktiin kalo CI itu mudah. Lightweight banged ^^ Kita buktikan saja.

Intussen beginnen de 2 laatste maanden van het jaar. Exact 1 jaar geleden was er de eerste succesvolle Zend Frameworks bughuntday. Volgende week komt een vervolg aan. Deze keer wordt er niet gesleuteld aan Zend Frameworks, nee. Het is nu de beurt van Symfony. Wat mij betreft, zal het eerder een grondige kennismaking worden. Ik zou blij zijn moest ik 1 bugje oplossen

Mensen die geïnteresseerd zijn, meer info vind je op de site van phpbenelux. Vergeet je wel niet in te schrijven.

Eventjes iets ander: eventjes terug naar mijn opleiding. Die is bijna volledig af en zelf heb ik al een deadline vooropgesteld die op eind december ligt. Een ruimegoede deadline voor mij en tijd genoeg om optionele delen te doen. Van tijd gesproken, deze week heb ik zowat geen les. En toch ben ik bezig met 3(!) dingen tegelijkertijd bezig. Daarbovenop komt mijn simpele site (eindelijk) en ben ik bezig met mijn stage (logischerwijs begin 2010) te regelen.

Dans le cadre de mon travail chez Autrement, je bosse principalement sur du développement web en Ruby, avec l’aide du framework Ruby on Rails.

Je suis focalisé sur le développement d’une appli web (encore un eu secrète pour le moment), mais là, Autrement édite par ailleurs le site web chambresapart.fr
Le développement de ce site a commencé bien avant que je rejoigne l’équipe et il s’appuie sur le framework Symfony, basé sur PHP.

Actuellement l’équipe Chambres à Part se compose de 2,5 personnes qui sont toutes les 3 des développeurs confirmés, spécialisés sur PHP / Symfony.

Avant le lancement de la “version 1″ de Chambres à Part, j’ai participé au développement de certaines fonctionnalités, mais principalement sur des aspects HTML, CSS, Javascript, cartographie Google + Maptimize, …
La dernière semaine a été uniquement consacrée à du debuggage et pour ça j’ai mis un peu plus mon nez dans le code source du site et donc dans la partie “vue” (le V de MVC).

Je ne peux surtout pas prétendre connaître Symfony dans ce qu’il a de particulier par rapport à d’autres framework web (et MVC en particulier), mais je peux comparer ce que j’ai vu et ce que l’équipe raconte au quotidien avec ce que je connais et vis au quotidien depuis 3 ans avec Ruby et Rails.

De plus, j’ai développé quasi-exclusivement en PHP depuis les premiers temps du PHP3 jusqu’à PHP5, donc même si j’ai passablement oublié certains réflexes de manipulation du langage et la plupart de noms de méthodes, je pense avoir un avis assez circonstancié sur PHP.

La question

Pour le développement de la partie visible du projet sur lequel je suis mobilisé, d’autres personnes de l’équipe vont participer activement et durablement. Une question se pose donc inévitablement : Ruby on Rails ou bien Symfony ?

Notre boss comprend bien quand on lui parle de technique, avec des arguments clairs, mais il ne se sent pas (à raison) en mesure de décider lui-même d’un framework ou d’un langage plutôt qu’un autre. Il nous a donc demandé de préparer une discussion sur cette question, en apportant surtout des faits et des remarques objectives afin de tout mettre sur la table et tenter en équipe de prendre la bonne décision.

Je suis convaincu qu’il ne s’agit pas de valider ou invalider les choix des uns et des autres, mais plutôt de faire un état des lieux et s’orienter dans la meilleure décision.

Comme je suis quelqu’un de passionné, et qui ne se lance dans les choses qu’avec une forte conviction, j’ai quand même envie de convaincre que mon choix de quitter le développement en PHP pour le faire en Ruby n’est pas juste “mon choix” mais un choix lucide et cohérent.

Alors j’ai sorti un bout de papier et un crayon (ou plutôt un document “untitled.txt” et mon beau clavier) pour pondre une liste d’arguments.

Et puis je me suis dit que garder tout ça pour nous, en interne, était un peu égoïste. Pourquoi ne pas partager mes observations et mon analyse. Je ne pense pas que quiconque (au delà de notre équipe et mes copains geeks) s’intéresse à mon avis sur la question, mais un avis, ça peut donner des idées, participer à une réflexion, …

Présentation factuelle de Ruby et Rails

Ici je ne présente que des points clés, du moins ceux auxquels j’ai pensé.
Je ne détaillerai pas ces points, d’autres l’ont fait bien mieux que moi.

Ruby

• 100% objet, pas de primitives
• langage concis et lisible : moins de code, moins de bugs
• langage dynamique, fortement typé
• imprégné des méthodes de tests TDD et BDD (nombreux frameworks disponibles)
• synergie avec les méthodes agiles
• Ruby en ligne de commande (IRB), pratique pour des essais, …
• Rubygems : gestionnaire de paquets additionnels
• vitesse d’apprentissage
• syntaxe et idiomes riches et avancés
• meta-programmation
• inspiré des meilleurs langages reconnus : Smalltalk, Lisp, Python, Perl, …
• forte implication et marques de confiance des ténors : IBM, Sun, Apple, Microsoft, SAP, …
• de nombreux frameworks de premier plan : Rails, Sinatra, …

J’invite à la lecture de la page de Ruby sur Wikipedia, que je trouve assez complète et claire.

Rails

• dédié au développement d’appli web
• architecture MVC
• naturellement REST
• forte incitation à DRY
• convention plutôt que configuration
• grand variété de helpers
• des outils annexes très utiles : débuggage, déploiement, monitoring, …
• des environnements d’exécution bien définis et cloisonnés
• WebServices-friendly
• système strict de migration des bases de données
• framework complet accessible en ligne de commande
• variété de backend pour le cache et les sessions : mémoire, fichiers, BDD, memcached, …
• I18n
• communauté très active
• documentation riche (en ligne, livres, …)
• Rack middlewares => empilement de briques fonctionnelles dédiées et modulaires : cache, debug, auth, …
• logging avancé et personnalisable
• fortes opinions, mais autres choix possibles : ORM, templates, framework JS, …

Pour une introduction à Rails, je vous renvoie vers le le guide de démarrage pour Rails ou Rails in a Nutshell (qui est encore en beta).

Analyse subjective (mais convaincue) de Ruby & Rails vs. PHP & Symfony

Là, je sors un peu des faits indéniables pour m’aventurer dans ma propre analyse des différences entre ces 2 frameworks (et leur langage sous-jacent respectif). Cette analyse est forcément subjective et je serai ravi d’entendre des avis contraires ou complémentaires.

PHP vs. Ruby

Prenons la métaphore de la caisse à outils.

PHP est une énorme caisse, dans laquelle il y a des outils pour presque tout, tellement que ça devient difficile de tout connaître. Il n’y a qu’à voir le site de la documentation officielle où le nombre de méthodes est impressionnant, sans parler de celles des librairies standards.

Il y a souvent plusieurs outils ou variantes pour faire presque la même chose. C’est pas forcément facile de savoir lequel choisir.

Cette boîte grandi très vite, il y a régulièrement de nouveaux outils, d’autres évoluent et certains disparaissent.

Ruby est une caisse beaucoup plus modeste, qui permet de faire tout autant de chose, mais il y a très peu de doublons ou recoupements.

Les outils sont robustes, stables et surtout cohérents entre eux. Le contenu de la boîte évolue peu, rarement et uniquement en cas de forte nécessité. Même entre les versions majeures (1.8 et 1.9) il y a très forte compatibilité. Au sein de la branche 1.8 il n’y a eu presqu’aucune perte de compatibilité importante depuis plus de 3 ans (sortie de la 1.8.5 en août 2006).

Les mises à jour de Ruby, en tant que langage, sont rares (12 à 18 mois entre chaque version stable) car il n’y a pas ou extrêmement peu de bugs, elles ne concernent que des nouveautés ou améliorations de fond. La raison de ce très faible nombre de bugs et failles de sécurité sont simples : le code est soumis à des tests systématiques et poussés (c’est dans la culture de la communauté Ruby) et le code étant simple lisible et clair, il est facile de l’auditer et le comprendre et donc d’en débusquer les failles.

À l’inverse, PHP est mis à jour beaucoup plus souvent (plusieurs fois par an) et contient de nombreux correctifs de bugs en plus de nouvelles fonctionnalités. Il est reconnu que les failles de sécurité importantes ou critiques sont relativement fréquentes.

La raison d’être de PHP n’était pas d’apporter une approche nouvelle du développement mais de répondre à un besoin simple et bien identifié : traiter les données issues d’un formulaire web. La simplicité et les fonctionnalités de ce nouveau langage l’ont rendu rapidement populaire chez les développeurs web car il n’y avait plus besoin de faire des CGI en Perl pour rendre des sites dynamiques.

Face à ce gain de popularité, le langage a grandi et permis de faire de plus en plus de choses assez facilement, mais rapidement on a constaté le manque de fondations solides, en particulier sur l’aspect Objet.

PHP rivalise alors, en terme de popularité et d’audience, avec Perl, Java, … et cherche alors à combler les manques et répondre aux critiques. Le résultat est plutôt efficace, mais les outils du début restent là et les mauvaises pratiques qui vont avec aussi.

Au final on a un langage riche, mais brouillon, fourre-tout, qui évolue par stratification et pas par transformation. Les fondations manquent de rigueur et de profondeur.

Ruby est un langage qui a été conçu avec une approche plus scientifique et globale. Son créateur voulait un langage moderne, plus proche des attentes de l’humain que de celles de la machine, mais qui reconnaisse et embrasse l’état de l’art, ce qui s’est fait de mieux. Il s’est donc contenté (si on peut dire) d’appliquer la parole des vieux sages dans un contexte moderne.

Ruby adopte le principe de la moindre surprise (au sens de la cohérence maximale) selon lequel le langage doit se comporter de manière à minimiser la confusion. Lorsqu’on découvre Ruby, qu’on vienne de Java, PHP ou Python, on est forcément surpris par la syntaxe, les idiomes, … mais avec le temps on adopte la “manière Ruby” et plus rien n’étonne. Dans d’autres langages, même après plusieurs années d’utilisation, on est parfois étonné ou dérouté par certains fonctionnements.

La syntaxe du langage est au service de son utilisateur, en favorisant la lisibilité et la concision. La simplicité des outils de base permet d’apprendre vite et de savoir rapidement lequel utiliser.

Ruby est bâti sur des fondations robustes et très strictes ; celles du tout Objet (il n’y a pas de primitives), de la meta-programmation, du typage dynamique mais fort, …

Symfony vs. Rails

Ruby on Rails est issu du développement d’une application web (Basecamp). Son créateur voulait se lancer dans le développement web et a cherché le langage avec lequel il se sentait le plus à l’aise et il s’est arrêté sur Ruby. Il a ensuite échafaudé un framework dédié au web en tirant réellement parti de ce que permet Ruby.

La démarche partait d’un objectif/besoin connu, il fallait trouver l’outil adapté pour l’atteindre.

Rails ne serait pas ce qu’il est sans Ruby. On ne peut pas recréer Rails sur un autre langage sans faire des tours de passe-passe et en perdre l’essence.

Symfony est issu du manque de bon framework web en PHP. Son créateur a voulu reprendre les bonnes idées d’autres frameworks (surtout Rails) sur d’autres langages pour les adapter sur PHP.

La démarche semble différente et partir d’un langage connu sur lequel construire en s’inspirant de références.

Pour ce que j’ai pu en voir et pour que Symfony ait le succès qu’il a, son développeur principal et la communauté qu’il a agrégée ont forcément accompli quelque chose de remarquable.

Pour autant, j’ai le sentiment que le plus grand handicap de Symfony, c’est PHP.

Conclusion

Au final, on sent que j’ai les idées bien arrêtées. J’espère ne pas avoir faire preuve de mauvaise foi ni avoir dit trop de bêtises.

Il m’arrive de dire que telle techno ou tel produit sont nuls. Mais pour le cas de PHP (et donc de Symfony), je ne dis pas que c’est nul et bon aux orties, au contraire.

Je dois certainement mon parcours de développeur web à PHP et à ce que j’ai pu faire avec. J’ai juste l’intime conviction d’avoir trouvé une évolution, une suite, qui me permet d’aller plus vite, plus loin, avec plus de plaisir/passion.

C’est un peu comme de passer de CVS ou Subversion à Git ou Mercurial. Vu de loin c’est la même chose, mais de près, ce sont 2 générations d’outils sui marquent un véritable progrès.

Mise à jour 1 : Au terme d’une longue réunion d’équipe, nous avons choisi une approche à 2 têtes. Le premier projet (Chambres à Part) reste évidemment développé avec Symfony (donc en PHP) mais le second sera entièrement développé avec Ruby on Rails.

Évidemment, je pense que c’est le bon choix. Pour moi, c’est surtout le bon choix technologique, pour toutes les raisons que j’ai déjà développées plus haut.

Du point de vue de la stratégie d’entreprise, je trouve que la prise de risque est modérée et ça va nous mettre dans une situation de réelle fusion et enrichissement des compétences.

Pendant les prochains mois, ceux parmi nous qui “viennent de Symfony” vont devoir apprendre de nouvelles choses en mettant à profit leurs années d’expérience en développement et particulièrement avec un framework MVC, … Le challenge sera de tirer le plus profit de cette expérience proche tout en “embrassant” les particularités de Ruby et de Rails.

Quelque part, ça va me mettre en situation de formateur, ce qui est très excitant mais aussi une responsabilité forte. Mais comme je suis absolument passionné par ce que je fais et connais, je vais me régaler dans cette partie de mon boulot.

Par ailleurs, cette juxtaposition d’outils va me permettre de voir plus en détail l’univers de Symfony et les évolutions de PHP (depuis que je l’ai laissé de côté). Même si je ne vois pas mon avenir de ce côté là, ça me forcera à être un peu moins monocorde.

Enfin bon, je suis bien content que la balance ait penché, non pas de mon côté (ça serait une marque d’égo) mais du côté que j’ai choisi.

Mise à jour 2 : Vous trouverez sur le site de Ruby une courte liste des similitudes et différences à quoi s’attendre en passant de PHP à Ruby.

Saludos amigos y amigas.

Algunas personas me han preguntado si se puede instalarle directamente PHP sobre el Internet Information Services, bueno, entonces me decidi en hacer un pequeño video de como se la realiza. Realmente es muy facil pero hay que tener ciertas consideraciones sobre todo en lo que ha configuración se refiere.

Con todo aqui se los dejo.

para ciertos temas que me han interesado como  y Symfony (Php Framework), LINQ, Entity Framework. El video fue realizado en la misma máquina de mi anterior blog.

Andrés A. Villenas.

En un proyecto reciente, tuve que ordenar una columna que contenía RUN, estas cadenas tienen entre 7 y 8 números enteros y un dígito verificador que puede ser un número entre 0-9 o una letra K, ordenar estas cadenas puede ser algo complicado pues el ordenamiento no es numérico.

En este sitio presentan una solución bastante sencilla, básicamente es sumarle un cero a la columna por la que queremos ordenar.

mysql> SELECT column FROM table_name ORDER BY column+0;

Esta idea se puede llevar a symfony simplemente añadiendo una cláusula de ordenamiento en un Criteria.

$c = new Criteria();
$c->addDescendingOrderByColumn('USERNAME+0');

Saludos!

JSON es una forma bastante cómoda de tratar con “objetos” y si lo usamos junto con AJAX puede resultar muy sencillo tratar con respuestas que contienen mas de un elemento, tales como una array o un objeto. En el siguiente ejemplo veremos como usar  jQuery y JSON para realizar consultas AJAX en symfony (sin helpers o similares)

Voy a evitar declarar el modelo de datos, por lo que supongo que el lector ya tiene algunos conocimientos básicos de este framework.

1.- El Action

Lo primero que haremos es crear un nuevo método para nuestro action, el objetivo es retornar un texto serializado con información de un usuario.

public function executeAjaxDatosCorredorById(sfWebRequest $request){

  /* Asegurar que la solicitud sea AJAX */
  if (!$request->isXmlHttpRequest())
    return $this->renderText(json_encode(array('error'=>'Sólo respondo consultas vía AJAX.')));

  /* si entra por POST o GET la variable sfUserId, continuar */
  if($request->getParameter('sfUserId'))
  {
     $usuario = sfGuardUserPeer::retrieveByPK($request->getParameter('sfUserId'));
     /* Crear array asociativo con los atributos del objeto $usuario */
     $datosUsuario = array(
        "nombre"    => $usuario->getProfile()->getNombre(),
         "apellidoP" => is_null($usuario->getProfile()->getApellidoP()) ? '' : $usuario->getProfile()->getApellidoP(),
         "apellidoM" => is_null($usuario->getProfile()->getApellidoM()) ? '' : $usuario->getProfile()->getApellidoM(),
         "rut"       => $usuario->getUsername()
      );

      /* retornar el arreglo en formato JSON */
      return $this->renderText(json_encode($datosUsuario));
   }
   return $this->renderText(json_encode(array('error'=>'Faltan parámetros para realizar la consulta')));
}

Listo. la respuesta está lista para ser “interpretada”. Ahora vamos a ver cómo procesamos la consulta:

2.- La funcion AJAX

Los parámetros de esta función son:
sfAction: es dirección http de la accion de symfony a ejecutar.
idTrigger: Id del elemento DOM que desencadena el evento.
valorParametro: valor que toma laa variable GET['sfUserId']

function getDatosUsuarioById(sfAction, idTrigger, valorParametro)
{
      $.ajax(
      {
        url: sfAction,
        data: ({sfUserId: valorParametro}),
        dataType: "json",
        beforeSend: function()
        {
          $("#"+idTrigger).append('<span id="cargando_datos"> Cargando datos...');
        },
        complete: function()
        {
          $("#cargando_datos").hide();
        },
        success: function (data, status)
        {
          $("#propuesta_nombre_contratante").val(data.nombre);
          $("#propuesta_apellido_p_contratante").val(data.apellidoP);
          $("#propuesta_apellido_m_contratante").val(data.apellidoM);
          /* ... etc */
        }
        error: function (data, status, e)
        {
            alert('Ocurrió un error cargando los datos solicitados:.\n'+data.error);
        }
    });
}

En la sección success se puede ver que la respuesta, representada por  data,  se interpreta como si fuera un objeto.

3.- La puesta en marcha

Para ver el código en funcionamiento debemos agregar el siguiente código en la vista o template en la que necesitemos la función recién implementada. En este ejemplo la función getDatosUsuarioById(…) se dispara al entrar en foco el elemento DOM con Id: propuesta_nombre_contratante. Por otra parte, nótese cómo se declara la variable sfCargaDatosUsuario, se utiliza el helper url_for para crear una ruta, utilizando enrutamiento absoluto, hacia el URL del action a ejecutar.

$(document).ready(function(){
  var sfCargaDatosUsuario  = "<?php echo url_for('propuesta/ajaxDatosUsuarioById')?>";
   $("#propuesta_nombre_contratante").focus(function()
   {
        if($("#propuesta_cliente_id").val()>0)
        {
            getDatosUsuarioById(
                sfCargaDatosUsuario,
                "propuesta_cliente_id",
                $("#propuesta_cliente_id").val(),
            );
        }
    });
});

Eso por el momento, espero le sea de utilidad a alguien, iré puliendo esta entrada para que quede más clara.

I’ve switched from Vim to netbeans in the past 9 months or so – I’ve been using Vim for 5+ years before that and finding an editor to beat it wasn’t easy. Main aim was to get better code completion, plus whichever editor I used had to have ‘hippie search‘  – this speeds up coding no end. Tried eclipse PDT along the way but found that too slow.

Ultimately netbeans persuaded me to convert. Here are some tips for using it:

General tips

• Use at least 6.8 beta version of netbeans – there are performance improvements for code completion which increase code completion a lot. If you’ve tried 6.7/6.5 – try again with the 6.8 beta+, especially with large projects.
• Enable hippie search – The default keys are ctrl+k and ctrl+shift+k – If you’re a Vim person, change these to ctrl+p and ctrl+n. The ‘Actions’ in the keymap editor are ‘Next matching word’ and ‘Previous matching word’
• Initiate code completion manually – use ctrl+space (default) I find the auto code completion popup just gets in the way. YMMV.
• Use Navigate menu – this allows you to find files/classes/functions/methods in your code almost instantly
• phpdoc your code: this allows code completion to work in places it otherwise could not

Symfony

• Ignore ‘test’ directories – make sure you ignore certain dirs in symfony. This makes code completion ignore classes under those directories.  I have problems with it picking up classes not in our project e.g. sfContext can get confused with sfContextMock from the tests.
• Symfony is supported in netbeans 6.8M2+ see http://blogs.sun.com/netbeansphp/entry/initial_symfony_support

we are web developer and designer company

Olá a todos,

recentemente tive um grande problema em relação ao embedforms do symfony. A tarefa era simples, encapsular um formulário dentro de outro com a opção de adicionar ou não um novo registro no BD. Este blog surgiu simplesmente por conta deste problema que enfrentei e vejo que muitos já enfrentaram e vão enfrentar.

Fiquei exatamente 3 dias pesquisando isto e não achei nada exato na internet, algumas dicas aqui e outras ali. Comecei a fazer tudo a minha própria maneira e finalmente consegui. O exemplo a seguir é com base no doctrine. Passei a usá-lo por diversos motivos que agora não entram em questão. Vejo que minha alternativa para este problema não me parece comum e nem a mais correta, porém foi a que encontrei e gostaria muito que outros compartilhassem tal assunto comigo.

Bom, vamos a situação.

Tenho 2 tabelas, uma chamada autor e outra livros, eis aqui o schema.yml:

Livro:
actAs:                  { Timestampable: ~ }
columns:
autor_id:               { type: integer   , notnull: true }
isbn:                   { type: string(50), notnull: true }
titulo:                 { type: string(50), notnull: true }
relations:
Autor: { onDelete: CASCADE, local: autor_id, foreign: id, foreignAlias: Livros }

Autor:
actAs:               { Timestampable: ~ }
columns:
nome:                { type: string(255), notnull: true }
sobrenome:           { type: string(255), notnull: true }

Simples. A nossa intenção aqui é criar um formulário semelhante a este:

formulário

Ok. Perceba no checkbox Novo Autor. É nisto que vou trabalhar neste artigo. A opção de escolher um autor já cadastrado ou adicionar um novo autor.

Bom, vamos lá. A primeira coisa que devemos fazer é modificar nosso LivroForm.class.php para a seguinte estrutura:

class LivroForm extends BaseLivroForm
{
  public function configure()
  {
  $autorForm = new AutorForm();

  //Adicionando Checkbox "adicionar novo cliente"
  $this->getWidgetSchema()->offsetSet(
    'add_new_autor', new sfWidgetFormInputCheckbox(array(
      'label' => 'Novo Autor')));

  $this->embedForm('new_autor', $autorForm);

  $this->widgetSchema['autor_id']->setOption(
    'add_empty', 'Escolher Autor');
  $this->validatorSchema['autor_id']->setMessage(
    'required', 'Por favor, escolha um autor ou crie um novo.');

  $this->setValidatorSchema(
    new LivroValidatorSchema($this->validatorSchema->getFields()));

  // Inserindo campos extras (checkbox no caso)
  $this->validatorSchema->setOption('allow_extra_fields', true);
  $this->validatorSchema->setOption('filter_extra_fields', false);
  }

  public function updateObject($values = null)
  {
  parent::updateObject();

  if ($this->values['autor_id'] <> 0)
  {
    //Salvando nosso livro com o ID do autor Setado no template
    $livro = new Livro();
    $livro->fromArray($this->values);
    $livro->save();

    return $this->object;
  } else {
    //Salvando nosso autor criado
    $autor = new Autor();
    $autor->fromArray($this->values['new_autor']);
    $autor->save();  

    //Salvando nosso Livro com o nosso autor criado
    $this->getObject()->setAutor($autor);
    $this->getObject()->save();
    return $this->object;
  }
  }
}

Ok.  Gostaria somente de comentar aqui a linha 43: $autor->save() e 47: $this->getObject()->save(). Na linha 43 nós estamos salvando o nosso novo cliente. Após salvar, nós pegamos o objeto autor e setamos no nosso objeto Boleto(linha 46). Logo depois nós salvamos nosso boleto, linha 47.

Nós precisamos modificar nosso validator para aceitar os novos campos adicionados (checkbox e o formulario encapsulado, autor).

Crie um arquivo chamado LivroValidatorSchema.class.php em /lib/validators:

class LivroValidatorSchema extends sfValidatorSchema {

  protected function doClean($values)
  {
    if (is_null($values)) {
      $values = array();
    }
    if (!is_array($values)) {
      throw new InvalidArgumentException(
        'You must pass an array parameter to the clean() method');
    }
    if (isset($values['add_new_autor'])) {
      $values['autor_id'] = '';
      $this->offsetUnset('autor_id');
    } else {
      if (isset($values['new_autor'])) {
        $values['new_autor'] = '';
        unset($values['new_autor']);
      }
    $this->offsetUnset('new_autor');
    }
  return parent::doClean($values);
  }
}

protected function processForm(sfWebRequest $request, sfForm $form)
{
  $form->bind($request->getParameter($form->getName()));
  if ($form->isValid()) {
    $form->updateObject();
    //$livro = $form->save();
    //$this->redirect('livro/edit?id='.$livro->getId());
    $this->redirect('livro/index');
  }
}