Voici une petite astuce pour ceux qui développent avec Symfony / Symfony 2 sous Windows et qui veulent avoir une console de génération de code plus agréable.

Sous distribution Linux, vous avez surement remarqué que la sandbox / console de Symfony s’affiche avec une légère mise en page et coloration syntaxique grâce à la gestion particulière des séquences ANSI de POSIX (environnements UNIX).

Vous serez très content de savoir que l’on peut bénéficier de cet avantage sur les plateformes Windows x86 et x64 grâce à la librairie ANSICON qui permet la reconnaissance des formatages spéciaux ANSI.

L’utilisation en est très simple, il suffit de télécharger la librairie ANSICON à l’adresse suivante : http://adoxa.110mb.com/ansicon/ .

Ensuite, il faudra décompresser l’ensemble dans un dossier e lancer « ansicon.exe » dans le répertoire x86 ou x64 en fonction de votre environnement Windows. Cela vous ouvrira un invite de commande Windows avec la gestion de la coloration syntaxique.

D’une manière générale, en développement PHP j’ai beaucoup utilisé Eclipse (en priorité), Netbeans (pour Symfony 1.x) et Zend Studio (autrement dit Eclipse avec une licence à 300 €)

Depuis quelques temps, je suis en totale admiration devant PhpStorm de l’éditeur JetBrains, qui dans la lignée de IntelliJ et Webstorm offre une IDE complet sur PHP : très léger, auto-completion Smarty et Twig, gestion de Zend et Symfony, build avec phing, … Bref le top du top et à un coût raisonnable et justifié.

En revanche pour Symfony 2, un plugin très intéressant et complet se prépare sur Eclipse : http://pulse00.github.com/Symfony-2-Eclipse-Plugin/

A priori, le plugin s’avère extrêmement intéressant, pour l’instant il reste en version de développement, notamment à cause de la version 3.0 du PDT qui n’est toujours pas finalisée (au passage vous avez constaté l’humiliation qui a été dévoué au PDT sur la page de téléchargement d’Eclipse).

Je mets à disposition une version sympa pour développer sur SF2 qui contient :

- Eclipse 3.7

- Eclipse MarketPlace

- PDT 3.0

- Support du YAML

- Plugin Symfony 2

- Support de Twig

- Support SVN et GIT

- Support GITHUB

Vous pouvez télécharger la version Windows ici : http://download.alexandre-julien.com/EclipseSF2.zip (286 Mo)

Vous pouvez également suivre le tutoriel de la Ferme Du Web pour configurer votre Eclipse avec le plugin Symfony2 : http://www.lafermeduweb.net/tutorial/installer-et-configurer-symfony-eclipse-plugin-pour-symfony2-p93.html

Vivement aussi que PHPStorm supporte Symfony2 prochainement

Zend vient de diffuser une première version de développement de Zend Framework 2.0 afin de faire découvrir les quelques nouveautés de la bibliothèque PHP5.

Au programme, tout comme Symfony 2, Zend Framework 2.0 sera entièrement conçu pour PHP 5.3 avec les « namespaces ».

Pas de nouvelle pour Zend Tool à l'heure actuelle

Toutefois rien de bien nouveau sur cette version de développement. Elle correspondant principalement aux librairies de ZF 1.10.

Les seuls nouveautés concernent apparemment les tests unitaires qui seraient plus simplifiés, une ré-écriture totale de Zend_Session ainsi que l’ajout d’une nouvelle librairie Zend_stdlib permettant d’appeller les librairies standard de PHP d’une façon plus orienté objet et plus harmonisée.

Structure identique à Zend Framework 1.10

Bonjour à tous,

Je vous informe que j’ai désormais arrêter le projet Phoogle Map. Les raisons sont multiples, et je me dois de vous en faire part :

- Changement majeur de l’API de Google Map V3 m’obligerait à faire une ré-écriture complète de la librairie

- Je manque considérablement de temps libre pour continuer à faire avancer ce projet, entre mes devoirs d’étudiants, mes stages en alternances et à temps plein, j’ai peu de temps libre pour moi.

- Je recommande fortement l’utilisation d’un plugin Symfony dont les classes peuvent être utiliser indépendamment du framework. Le projet s’appelle sfEasyGMapPlugin est il est disponible à cette adresse : http://www.symfony-project.org/plugins/sfEasyGMapPlugin. Ce projet est très sérieux et il est utilisé très professionnellement par de nombreux sites Web.

- PhoogleMap a très peu de succès, seulement 190 téléchargements en 9 mois pour la dernière version.

- PhoogleMap a été conçu pour une utilisation orienté productivité et pour une utilisation nécessitant aucune connaissance sur l’API de GoogleMap principalement a destination des freelances et SSII pour leurs projets. Or la demande actuellement est plutôt orienté grande intégration et qualité, les entreprises développent de plus en plus leurs propres librairies pour répondre à leur besoin.

Je remercie ceux qui auront utilisé ce projet et qui auront prêté de l’intérêt. Le projet reste disponible en licence GNU / GPL néanmois il est basé sur la version 2 de Google Map API est désormais obsolète pour être remplacer par la version v3.

Il est très utile dans une application Web d’avoir un système de navigation capable de cartographier les pages d’un site et d’en déduire des plan de site, fils d’arianes, menus, sitemap.xml, …

Zend_Navigation a été conçu dans cette optique, il propose un système de gestion de pages et des helpers pour générer des composants graphiques.

Nous allons voir dans ce tutoriel une façon simple de mettre en place Zend_Navigation :

Tout d’abord il nous faut définir la navigation et le conteneur de donnée. Dans notre cas, on stockera l’arborescence dans un fichier XML appellé ‘navigation.xml’ dans le répertoire « config ».

protected function _initNavigation() {
$this->bootstrap('layout');
$layout = $this->getResource('layout');
$view = $layout->getView();
$config = new Zend_Config_Xml(APPLICATION_PATH . '/configs/navigation.xml', 'nav');
$container = new Zend_Navigation($config);
$view->navigation($container);
}
<div>

Ensuite, on remplit le fichier « navigation.xml » pour créer notre navigation, on y indiquera la page d’accueil et une page de listing.
On se basera sur le système de routes pour donner le lien.

<configdata>
 <nav>
 <home>
 <label>Accueil</label>
 <route>index</route>
 <pages>
 <listing>
 <label>Liste CRUD</label>
 <route>listing</route>
 </listing>
</pages>
</home>
</nav>
</configdata>

Et voilà la mise en place de Zend_Navigation est fini. Il ne vous reste plus qu’à utiliser des helpers pour appeler vos composants :
Pour le breadcrumb par exemple :

$this->navigation()->breadcrumbs()->setSeparator(" -> ");

Il existe d’autres façon d’intégrer Zend_Navigation sur une application notamment en intervenant directement sur le code. Cette méthode reste très simple mais très fonctionnelle. On y pourra voir des améliorations comme mettre en place un cache pour augmenter les performances.

L’extension est téléchargeable à cette adresse : https://chrome.google.com/extensions/detail/kfiahljocaflpaiopilgpiochncgdnhd

Les résultats de recherche sont identiques à ceux du moteur de recherche de PHP.NET

Une rumeur circule depuis quelques temps, à propos d’une ré-inventation de PHP par Facebook pour optimiser les performances de leurs applications. Cette dernière a été désormais par la firme, un ingénieur a travaillé sur une refonte de la runtime de PHP afin d’avoir un résultat compilé et non plus interprété comme c’est le cas actuellement avec la runtime de Zend.

Le projet s’appelle HipHop et il s’appuie non pas sur un compilateur mais plutôt sur un transcodeur qui permet de passer d’un code PHP à un code C++ très optimisé et ce dernier pouvant être compilé avec g++.

Ce travail a mis plus de 2 ans avant de voir le jour et ce travail verra le jour très bientôt dans un projet Open Source sous licence Creative-Commons.

Voici le processus de HipPop pour optimiser une application PHP :

Il s’agit d’une transformation de code qui part de sources PHP, le code est parsé et ensuite optimisé avant d’être traduit en C++. Le code C++ est lui aussi optimiser et ensuite il est compilé via G++ en langage machine.

Certaines fonctions trop gourmande comme « eval() » ne seront pas supportées mais la globalité du langage est supportée.

Les essais de Facebook révèleraient un gain de performance de l’ordre de 80 % coté processeur et l’application Facebook elle-même devrait migrer sur cette technologie d’ici quelques semaines ou quelques mois. Ils devraient réduire de 50 % l’utilisation du CPU pour héberger Facebook ce qui constitue une économie intéressante puisqu’au dernières nouvelles Facebook, utiliserait plus 30 000 machines pour héberger son réseau social.

La preuve c’est qu’ il s’agit du 3ème point qui influe le plus le référencement d’une page. Et puis on peut également avoir besoin internationaliser ses urls.

Zend Framework possède un routeur, qui permet de manipuler plus facilement les liens entre les pages au sein d’une application et également de faire de la réécriture.

Cette étape se fait au sein du Bootstrap d’une application Zend Framework et grâce à Zend_Controller.

Il faut tout d’abord surcharger la méthode _initAutoLoad() du Bootstrap et récupérer l’instance de Zend_Controller

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

// Surcharge de _initAutoLoad
protected function _initAutoload()

{
$moduleLoader = new Zend_Application_Module_Autoloader(array('namespace'=>'', 'basePath'=>APPLICATION_PATH));

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();

return $moduleLoader;
}

}

Ensuite il suffit simplement de créer ses routes et de les rajouter au routeur du contrôleur.
Pour cela on a plusieurs possibilités, on peut créer des routes statiques, des routes basées sur les modules, etc …
Le plus efficace est de créer des routes à partir d’URL pré-formatées grâce à des expressions régulières.
On devra donc créer des instances de la classe Zend_Controller_Router_Route_Regex.

On la construira avec les arguments suivants :

1) La route : sous forme d’expression régulière (exemple : ‘produits/(.+)/(.+)/article-(.+)-(.+).html’)
2) Le lien MVC : il faut donner les éléments statiques pour accéder à la page, c’est à dire le module, le contrôleur et l’action cible (exemple : array(‘module’ => ‘default’, ‘controller’ => ‘products’, ‘action’ => ‘showProduct’))
3)Le mapping des paramètre : on donne dans l’ordre le nom des paramètres que l’on passera dans l’Url (exemple : array(1 => ‘category’, 2=> ‘subcategory’, 3 => ‘product_title’, 4 => ‘product_ref’))
4) Le chemin inverse : une version de l’url interprétable par la fonction sprintf() de PHP (exemple : ‘produits/%s/%s/article-%s-%d.html’)

class Bootstrap extends Zend_Application_Bootstrap_Bootstrap {

// Surcharge de _initAutoLoad
protected function _initAutoload()

{
$moduleLoader = new Zend_Application_Module_Autoloader(array('namespace'=>'', 'basePath'=>APPLICATION_PATH));

$frontController = Zend_Controller_Front::getInstance();
$router = $frontController->getRouter();

// Nouvelle route pour accéder à produit
$article = new Zend_Controller_Router_Route_Regex(
 'produits/(.+)/(.+)/article-(.+)-(.+).html',
 array('module' => 'default', 'controller' => 'products', 'action' => 'showProduct'),
 array(1 => 'category', 2=> 'subcategory', 3 => 'product_title', 4 => 'product_ref'),
 'produits/%s/%s/article-%s-%d.html');
$router->addRoute($article);

return $moduleLoader;
}

}

Ainsi on pourra créer et appeler une url de type : « www.maboutique.com/produits/processeurs/dual-core/article-intelcore2duo-PI5421.html »

A l’heure où les environnements de développement pour PHP sont majoritairement basé sur Eclipse : PHP Development Tools, Aptana et Zend Studio, Netbeans quant à lui se faisait très discret dans le domaine des IDE PHP.

Voici la nouvelle version de NetBeans en release 6.8 avec des outils de développement pour PHP 5 fort intéressants :

Tout d’abord il existe une version de l’IDE entièrement dédié au développement PHP comme c’est le cas de la version All-In-One d’Eclipse.

- Il supporte également la version 5.3 de PHP

- Débugage de PHP dans l’IDE

- Exécution et pilotage de test-unitaires mis en place avec PHPUnit

- Support du Framework Symfony (autocompletion, exécution d’actions en ligne de commande depuis une console dans l’ide, support du YAML, …)

Nous allons nous intéresser au support de Symfony dans l’IDE et voir si son usage facile le développement avec le framework PHP français !

L’interface de NetBeans 6.8 est relativement simple, ergonome et traduite dans toutes les langues pour les non-anglophones.

1. Paramétrage de NetBeans pour PHP

Le paramétrage de NetBeans se fait en 3 étapes :

- Le chemin de l’exécutable « php.exe »
- Le chemin du script de PHPUnit (facultatif)
- Le chemin de la sandbox de symfony (symfony.bat ou symfony.sh)

Vous devez spécifier le chemin de votre serveur PHP, c’est à dire l’emplacement du « php.exe » de votre installation pour utiliser les fonctions de débugage, compilation et exécution de code PHP en « Command Line Interface ». Dans mon exemple, je donne le chemin d’accès de mon installation WAMP.

En suite, il vous faudra spécifier le chemin d’accès à la sandbox de Symfony, sous Windows il s’agit du fichier « symfony.bat ».

2. Création de votre projet Symfony

Pour créer votre projet Symfony, rien de plus simple, il suffit d’aller sur « Fichier -> Nouveau Projet » et de créer un nouveau projet « Application PHP ».

Donnez ensuite, un nom à votre projet, sélectionnez la version de PHP utilisée, dans notre cas, on pourra se contenter de la version 5.2.x.
N’oublier pas de donner le répertoire contenant le code source  du framework Symfony cela fonctionne avec n’importe quelle version du framework à priori sauf peut être pour la version en développement 2.0.

Pour ce qui est de la configuration de l’environnement de production pour le déploiement, nous n’avons pas à nous en soucier. On se contentera d’un environnement serveur en local.

Enfin on pourra spécifier que l’on veut utiliser le framework Symfony et que l’on veut générer une application « frontend » (application web principale destinée aux visiteurs du site) et une application « backend » (application dédiée à l’administration et au backoffice de l’application principale).

3. Dans la pratique

Voici comment se présente notre projet Symfony sous Netbeans 6.8. Nous avons un très bon éditeur de YML / YAML avec coloration syntaxique, autocompletion et schéma hiérarchique

On pourra également utiliser l’outil de génération de code en ligne de commande de Symfony en allant sur « MySymfonyProject -> click-droit -> Run Symfony Command ».

On a le résultat de l’exécution de la ligne de commande dans le partie console de NetBeans cet outil est très pratique pour exécuter les tests-unitaires de LIME le framework de test intégré à Symfony.

On niveau du développement « pur », on constate que l’autocompletion répond bien à la plupart des besoins de développeurs : les objets des vues, contrôleurs comme $sfWebRequest, $sfWebResponse, $view peuvent être appeler sans problème avec une intelliSense et même avec une petite documentation.

Conclusion

Ce support du framework Symfony est très intéressant à la fois pour la communauté des développeurs Symfony mais aussi pour NetBeans qui pourra peut être se faire une meilleure réputation dans le développement PHP car il faut le rappeler Symfony est le framework de développement PHP le plus utilisé avec Zend Framework . Les fonctionnalités de NetBeans vis à vis de ce framework sont très basiques mais relativement utiles. On regrettera peut être une meilleure intégration du framework de test unitaire et une génération de code plus importante. Peut-être vaut-il le coup d’être utiliser à la place d’Eclipse ou Aptana dans une optique de développement Symfony ? Ou aurons-nous du mal à nous séparer de nos bons vieux plugins sur Eclipse (pour Subversion, Database Explorer, PDT, Smarty, jQuery) ? Pour ma part, NetBeans a gagné ma confiance, je lui trouve une bonne ergonomie et une grande simplicité d’utilisation. Il existe une autre solution  pour le support de Symfony mais qui est quant-à-elle payante : il s’agit de PHPEdit il faut compter environ 219€ pour une version avec le support de Symfony et presque 300 € pour le support de PHPUnit et SVN.

Aptana PHP Theme

La sortie de cette nouvelle version s’accompagne d’une amélioration de la rubrique PhoogleMap sur le site avec des exemples téléchargeables, des sources mises à jour, une présentation approfondie, une PHP Doc en anglais, et des nouvelles ressources.

Très prochainement, je rajouterai une documentation complète en français et en anglais ainsi que de nouveaux exemples.

Aptana Studio est un IDE (Environnement de Développement orienté) Web 2.0 et basé sur les fondations d’Eclipse. Son principal avantage est qu’il n’utilise pas les plugin’s traditionnels d’Eclipse au profit de plugin’s développés par aptana qui sont beaucoup plus performants et plus astucieux.

Le logiciel est un environnement complet pour :

- PHP (sans passer le PDT d’Eclipse)

- Ruby On Rails

- Python Web

- Framework Javascript : jQuery, Prototype, Mootools, Adobe Spry, Dojo, …

- Javascript, HTML, CSS

- Application Adobe Air, Flex, …

De plus, vous pourrez installer tous vos plugins préférés sur Aptana ou bien inversement, installer les plugins d’Aptana sur votre Eclipse existant !

Aptana est totalement libre et disponible sur Windows, MacOS X, Linux. Certaines personnes pourront également le coupler à une version 64 bits d’Eclipse sous Linux.

Rendez-vous sur le site Officiel : http://www.aptana.com

Voici un tutorial pour créer une application « composant » sur Joomla! grâce à la nouvelle API basé sur Joomla framework MVC 1.5

Le gros avantage de la version 1.5 par rapport à la version 1.0, c’est qu’elle propose une API bien mieux construire et rend beaucoup plus agréable le développement d’applications. Le nouveau framework est basé sur le design-pattern MVC bien que la couche modèle est quelque peu inutile, étant donné que Joomla 1.5 ne fonctionne avec rien d’autre que MySQL, cela dit, on a le choix entre les drivers « mysql » ou « mysqli ».

Nous illustrerons une application simple qui saisie des utilisateurs dans une table et qui les affiche sous la forme d’une liste. Cette application nous permettra de voir d’une façon pragmatique la structure des applications Joomla! et les fonctions de base du framework : création d’une classe modèle (ajout, mise à jour, suppression et requêtes en base de données), création d’un controller avec les actions de base (une action pour création et édition et une autre pour le listing), gestion des templates, redirections et notifications des erreurs et succès.

Télécharger Joomla! 1.5.x : Joomla_1.5.15

Télécharger l’application : Joomla! Crud Tutoriel

Voici ci-dessous la hiérarchie de notre application, il s’agit d’un répertoire à créer dans le dossier « components » de Joomla! :

Voici le script SQL correspondant à la table « jos_crud_users » qui contient les données :

--
-- Structure de la table `jos_crud_users`
--

CREATE TABLE IF NOT EXISTS `jos_crud_users` (
 `user_id` int(11) NOT NULL AUTO_INCREMENT,
 `user_name` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,
 `user_lastname` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,
 `user_email` varchar(255) CHARACTER SET utf8 COLLATE utf8_bin NOT NULL,
 PRIMARY KEY (`user_id`)
) ENGINE=MyISAM  DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

Voici le premier fichier à créer, « crud.php » il s’agit du fichier d’entrée qui est exécuté dès qu’un utilisateur visite l’application :

<?php
/**
 * @package    Joomla.Crud
 * @subpackage Components
 * components/com_crud/crud.php
 * @link http://www.alexandre-julien.com
 * @author Alexandre JULIEN
 */

// Pas d'accès direct à la page
defined( '_JEXEC' ) or die( 'Restricted access' );

// Requiert la classe des contrôleurs

require_once( JPATH_COMPONENT.DS.'controller.php' );

// Requiert un contrôleur spécifique si demander
if($controller = JRequest::getVar('controller')) {
 $path = JPATH_COMPONENT.DS.'controllers'.DS.$controller.'.php';
 if (file_exists($path)) {
 require_once $path;
 } else {
 $controller = '';
 }
}

// Instanciation du contrôleur
$classname    = 'CrudController'.$controller;
$controller   = new $classname( );

// Execute la tâche demandée
$controller->execute( JRequest::getVar( 'task' ) );

// Redirection si elle est sollicitée par le contrôleur
$controller->redirect();
?>

Voici maintenant le contrôleur, chaque méthode correspond à une tâche accessible par l’url : « index.php?option=com_crud&task=lamethode »

<?php
/**
 * @package    Joomla.Crud
 * @subpackage Components
 * @link http://www.alexandre-julien.com
 * @license GNU / GPL
 * @author Alexandre JULIEN
 */

// No direct access

defined( '_JEXEC' ) or die( 'Restricted access' );

jimport('joomla.application.component.controller');

/**
 * Hello World Component Controller
 *
 * @package    Joomla.Tutorials
 * @subpackage Components
 */
class CrudController extends JController
{
 /**
 * Méthode d'affichage
 *
 * @access    public
 */
 function display()
 {
 $model = $this->getModel();
 $view = $this->getView('list', 'html');
 $view->users = $model->getAllUsers();
 $view->display();
 }

 /**
 * Formulaire de création d'un utilisateur
 * @return unknown_type
 */
 function add()
 {
 $view =& $this->getView('edit', 'html');
 $view->display();
 }

 /**
 * Formulaire d'édition d'un utilisateur
 * @return unknown_type
 */
 function edit()
 {
 if (isset($_GET) && isset($_GET['id']))
 {
 $view = $this->getView ('edit', 'html');
 $model =& $this->getModel();
 $view->data = $model->getUser($_GET['id']);
 $view->display();
 }
 else
 {
 $this->setRedirect('index.php?option=com_crud', "L'identifiant est manquant", 'error');
 }
 }

 /**
 * Sauvegarde d'un utilisateur
 * @return unknown_type
 */
 function save()
 {
 if (isset($_POST))
 {
 $model =& $this->getModel();
 if (isset($_POST['id']) && $model->getUser($_POST['id']))
 {
 $model->updateUser($_POST);
 }
 else
 {
 $model->addUser($_POST);
 }
 $this->setRedirect('index.php?option=com_crud', "Les modifications ont bien été enregistrées", 'message');
 }
 else
 {
 $this->setRedirect('index.php?option=com_crud', "Les données sont manquantes", 'error');
 }
 }

 /**
 * Suppression d'un utilisateur
 * @return unknown_type
 */
 function delete()
 {
 if (isset($_GET) && isset($_GET['id']))
 {
 $model =& $this->getModel();
 $model->removeUser($_GET['id']);
 $this->setRedirect('index.php?option=com_crud', "L'utilisateur a bien été supprimé", 'message');
 }
 else
 {
 $this->setRedirect('index.php?option=com_crud', "L'identifiant est manquant", 'error');
 }
 }
}
?>

La couche modèle qui gère les transactions avec la base de données dans le fichiers « models/crud.php » :

<?php
/**
 * Crud modèle pour le composant Crud
 *
 * @package    Joomla.Crud
 * @subpackage Components
 * @link http://www.alexandre-julien.com
 * @license    GNU/GPL
 * @author Alexandre JULIEN
 */

// Pas d'accès direct

defined( '_JEXEC' ) or die( 'Restricted access' );

jimport( 'joomla.application.component.model' );

/**
 * Modèle Crud
 *
 * @package    Joomla.Crud
 * @subpackage Components
 */
class CrudModelCrud extends JModel
{
 /**
 * Retourne tous les enregistrements de la table
 * @return unknown_type
 */
 function getAllUsers()
 {
 $query = 'SELECT * FROM #__crud_users';
 return $this->_getList ($query);
 }

 /**
 * Retourne l'enregistrement en fonction de l'identifiant de l'utilisateur
 * @param $user_id
 * @return unknown_type
 */
 function getUser ($user_id)
 {
 $query = 'SELECT * FROM #__crud_users WHERE user_id = '.(int)$user_id;
 $result = $this->_getList ($query);
 return $result[0];
 }

 /**
 * Ajoute un enregistrement
 * @param $values
 * @return unknown_type
 */
 function addUser ($values)
 {
 $db =& JFactory::getDBO();

 $row = new stdClass();
 $row->user_name = $values['user_name'];
 $row->user_lastname = $values['user_lastname'];
 $row->user_email = $values['user_email'];

 $db->insertObject ('#__crud_users', $row);
 }

 /**
 * Met à jour un enregistrement
 * @param $values
 * @return unknown_type
 */
 function updateUser ($values)
 {
 $db =& JFactory::getDBO();

 $row = new stdClass();
 $row->user_id = $values['user_id'];
 $row->user_name = $values['user_name'];
 $row->user_lastname = $values['user_lastname'];
 $row->user_email = $values['user_email'];

 $db->updateObject ('#__crud_users', $row, 'user_id');
 }

 /**
 * Supprime un enregistrement
 * @param $id
 * @return unknown_type
 */
 function removeUser ($id)
 {
 $db =& JFactory::getDBO();
 $query = 'DELETE FROM #__crud_users WHERE user_id = '.(int)$id;
 $db->setQuery($query);
 return $this->query();
 }
}
?>

Voici un exemple de fichier « View.html.php », il s’agit de celui de l’écran de listing :

<?php
/**
 * @package    Joomla.Crud
 * @subpackage Components
 * @link http://www.alexandre-julien.com
 * @license   GNU/GPL
 * @author Alexandre JULIEN
 */

// Pas d'accès direct

defined( '_JEXEC' ) or die( 'Restricted access' );

jimport( 'joomla.application.component.view');

/**
 * HTML View pour afficher la liste des utilisateurs
 *
 * @package    Crud
 */

class CrudViewList extends JView
{
 function display($tpl = null)
 {
 $this->assignRef('data', $this->users);
 parent::display($tpl);
 }
}
?>

Le template de la vue « edit » :

<?php

// Pas d'accès direct

defined('_JEXEC') or die('Restricted access'); ?>

<h1>Edition d'un utilisateur</h1>
<form name="utilisateur" method="POST"
	action="<?php echo JRoute::_('index.php?option=com_crud&task=save') ?>">
<input type="hidden" name="user_id" value="<?php echo $this->data->user_id ?>" />
<table>
	<tbody>
		<tr>
			<th>Prénom de l'utilisateur</th>
			<td><input type="text" name="user_name"
				value="<?php if (isset($this->data)) { echo $this->data->user_name; } ?>" /></td>
		</tr>
		<tr>
			<th>Nom de l'utilisateur</th>
			<td><input type="text" name="user_lastname"
				value="<?php if(isset($this->data)) { echo $this->data->user_lastname; } ?>" /></td>
		</tr>
		<tr>
			<th>Email de l'utilisateur</th>
			<td><input type="text" name="user_email"
				value="<?php if(isset($this->data)) { echo $this->data->user_email; } ?>"></input></td>
		</tr>
	</tbody>
</table>

<br />
<br />
<input type="submit" value="Enregistrer" /></form>

Le template de la vue « list » :

<?php

// Pas d'accès direct

defined('_JEXEC') or die('Restricted access'); ?>

<h1>Liste des utilisateurs</h1>

<table>
	<tbody>
		<tr>
			<th>Nom</th>
			<th>Prénom</th>
			<th>Adresse e-mail</th>
			<th>Actions</th>
		</tr>
		<?php foreach ($this->data as $key => $value) { ?>
		<tr>
			<td><?php echo $value->user_lastname ?></td>
			<td><?php echo $value->user_name ?></td>
			<td><?php echo $value->user_email ?></td>
			<td><a
				href="<?php echo JRoute::_('index.php?option=com_crud&task=edit&id='.(int)$value->user_id) ?>">
			Editer </a> | <a
				href="<?php echo JRoute::_('index.php?option=com_crud&task=delete&id='.(int)$value->user_id) ?>">Supprimer</a></td>
		</tr>
		<?php } ?>
	</tbody>
</table>
<br />
<a href="<?php echo JRoute::_('index.php?option=com_crud&task=add') ?>">
Créer un utilisateur </a>

On pourra également créer un package Joomla! qui automatisera l’installation des fichiers et des tables SQL grâce à un fichier de configuration d’installation « hello.xml » :

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE install SYSTEM "http://www.joomla.org/xml/dtd/1.5/component-install.dtd">
<install type="component" version="1.5.0">
  <name>crud</name>
  <!-- Les éléments suivants sont optionnels  -->
  <creationDate>2009 09 21</creationDate>
  <author>Alexandre JULIEN</author>
  <authorEmail>mail@alexandre.julien.com</authorEmail>
  <authorUrl>http://www.alexandre-julien.com</authorUrl>
  <copyright>Le blog d'Alex</copyright>
  <license>GNU / GPL</license>
  <!--  Version du composant -->
  <version>stable 1.0</version>
  <!-- Description du Composant -->
  <description>Petit tutoriel CRUD pour illustrer Joomla! MVC Framework</description>

  <!-- Fichiers d'installation -->
  <files folder="site">
    <filename>crud.php</filename>
    <filename>controller.php</filename>
    <filename>models/crud.php</filename>
    <filename>views/edit/view.html.php</filename>
    <filename>views/edit/tmpl/default.php</filename>
    <filename>views/list/view.html.php</filename>
    <filename>views/list/tmpl/default.php</filename>
  </files>
  <install>
    <sql>
      <file charset="uft8" driver="mysql">install.sql</file>
      <file charset="utf8" driver="mysqli">install.sql</file>
    </sql>
  </install>
  <uninstall>
    <sql>
      <file charset="utf8" driver="mysql">uninstall.sql</file>
      <file charset="utf8" driver="mysqli">uninstall.sql</file>
    </sql>
  </uninstall>
  <administration>
    <!-- Administration Menu Section -->
    <menu>Joomla! CRUD</menu>

    <!-- Fichiers de la partie administration -->
    <files folder="admin">
      <filename>index.html</filename>
      <filename>install.sql</filename>
      <filename>uninstall.sql</filename>
    </files>
  </administration>
</install>

Voici des « screenshots » de notre application finale :

L’application est disponible ici dans cette archive : Tutoriel Joomla! CRUD (installation package)

Zend Framework possède son propre outil pour gérer les formulaires correctement : Zend_Form est là pour ça !
Il s’agit d’une librairie qui gère vos composants de formulaires (y compris leur rendu), les validations, le filtrage des données, et la gestion de sous-formulaires.
La librairie Zend_Validate qui gère les validateurs sera aussi utiliser dans ce tutoriel afin d’illustrer les validations de formulaire et ce de façon personnalisé.

Tout d’abord nous allons voir les principes basiques des formulaires avec Zend Framework : il nous faudra ajouter un dossier « forms » dans notre répertoire « application ».

Voici un premier example de la création d’un formulaire dans notre fichier « Author.php ». Il s’agit d’une classe qui correspondra à un formulaire d’inscription d’un auteur :

class Form_Author extends Zend_Form
{
  /**
   * Surcharge du constructeur du formulaire
   */
  public function __construct($options = null)
  {
    parent::__construct($options = null)
    $this->setName('subscription'); // On nomme le formulaire

    $id = new Zend_Form_Element_Hidden('id'); // On rajoute un champs caché

    $email = new Zend_Form_Element_Text('email');
    $email->setRequired(true)
          ->setLabel('Veuillez saisir votre e-mail');

     // Nous avons rajouter un attribut obligatoire à notre email et nous lui avons donné un libellé avant le champs texte

    // Ensuite on peut insérer les composants (elements) dans le formulaire
    $this->addElements($id, $email);

  }
}

Nous avons réaliser une ébauche de formulaire, pour l’utiliser dans notre contrôleur et vue, rien de plus simple

AuthorController.php

function suscribeAction ()

{

$form = new Form_Author(); // On instancie le formulaire

$this->view->form = $form // On le renvoie à la vue

}

// Pour l'éditer il faut renvoyer les informations au formulaire

function editsubscriptionAction()

{

$form = new Form_Author();

$model = new Model_DbTable_Author();

$data = $model->getAuthor('5'); // On récupère toutes les données d'un auteur dans la base de données

$form->populate ($data); // On propulse les données dans le formulaire

$this->view->form = $form;

}

Ensuite dans la vue, on affiche le formulaire et on définit son action :

Author.phtml

echo $this->form;
$this->form>setAction(author/save); // On définit l'action qui récupère le formulaire

Voici un exemple beaucoup plus complet d’un formulaire avec des validateurs, internationalisation et un captcha :

<?php
class Form_Author extends Zend_Form
{
public function __construct($options = null)
{
parent::__construct($options);
$this->setName('Subscription');
$id = new Zend_Form_Element_Hidden('id');

$translate = Zend_Registry::get('translate');

$emptyValidator = new Zend_Validate_NotEmpty();
$emptyValidator->setMessage($translate->_("Ce champs est vide : vous devez le compléter"));

$emailValidator = new Zend_Validate_EmailAddress();
$emailValidator->setMessage($translate->_('L\'adresse email n\'est pas valide'));

$primaryValidator = new Zend_Validate_Db_NoRecordExists('users', 'username');
$primaryValidator->setMessage($translate->_("L'adresse email a déjà été utilisée"), Zend_Validate_Db_Abstract::ERROR_RECORD_FOUND);

$stringLengthValdiator = new Zend_Validate_StringLength(6, 12);
$stringLengthValdiator->setMessage($translate->_('La longueur du mot de pase doit être comprise entre 6 et 12 caractères'));

$email = new Zend_Form_Element_Text('email');
$email->setLabel($translate->_('Email'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emailValidator)
->addValidator($primaryValidator)
->addValidator($emptyValidator);

$password = new Zend_Form_Element_Password('password');
$password->setLabel($translate->_('mot de passe'));
$password->addValidator($stringLengthValdiator);
$password->addValidator($emptyValidator);

$password_verification = new Zend_Form_Element_Password ('password_confirm');
$password_verification->setLabel ($translate->_('retapez le mot de passe pour vérification'));
$password_verification->addValidator($emptyValidator);
if (isset($_POST['password'])) {
$passwordVerificationValidator = new Zend_Validate_Identical($_POST['password']);
$passwordVerificationValidator->setMessage($translate->_('Les mots de passe ne correspondent pas'));
$password_verification->addValidator($passwordVerificationValidator);
}

$sex = new Zend_Form_Element_Radio('sex', array('separator' => ' '));
$sex->setMultiOptions (array('male' => 'Homme', 'female' => 'Femme '))
->setLabel($translate->_('Sexe'))
-> isRequired(true);

$name = new Zend_Form_Element_Text('name');
$name->setLabel($translate->_('Prénom'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$surname = new Zend_Form_Element_Text('surname');
$surname->setLabel($translate->_('Nom'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$address = new Zend_Form_Element_Text('address_author');
$address->setLabel($translate->_('Adresse'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$zip_code = new Zend_Form_Element_Text('zip_code_author');
$zip_code->setLabel($translate->_('Code Postal'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$city = new Zend_Form_Element_Text('city_author');
$city->setLabel($translate->_('Ville'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

$phone = new Zend_Form_Element_Text('phone');
$phone->setLabel($translate->_('Téléphone'))
->setRequired(true)
->addFilter('StripTags')
->addFilter('StringTrim')
->addValidator($emptyValidator);

}

$submit = new Zend_Form_Element_Submit('valid');
$submit->setAttrib('id', 'submitbutton')
->setLabel($translate->_('Enregistrer l\'annonce'));

 $this->addElements(array($id, $email,$password, $password_verification, $sex, $name, $surname, $address, $zip_code, $city, $phone, $submit));
}
}
?>

Dans le prochaine tutorial, nous verrons comment mettre en application tout ce que nous avons vu précédemment dans un « CRUD » (Create Read Update Delete) qui illustrera l’utilisateur du design-pattern MVC, Zend_Db, Zend_Form, Zend_Validate et Zend_Layout.

Il s’agit avant tout d’un projet Symfony 1.2 qui utilise le design pattern MVC, Doctrine et Symfony.

Le projet a l’air très prometteur, il est toujours en version de test mais on peut dors-et-déjà le télécharger sur le site Officiel : http://www.sympalphp.org

Le CMS a l’air tout aussi complet qu’un Drupal, Spip ou Joomla et s’intègrera parfaitement avec les applications Symfony.

Voici 2 screencasts présents sur le site officiel pour illustrer le fonctionnement de l’application :

Très rensemblante à la debug bar de Symfony, un petit projet fait avec Zend Framework nommé ZFDebug ravira beaucoup de développeurs Symfony. Il s’agit d’une petite debug bar qui se place en haut de la page web et qui renseigne le développeur sur un grand nombre d’informations : temps de réponse, utilisation de la mémoire, requêtes à la base de données, …

Les principales informations qu’offre ZFDebug sont les suivantes :

• Cache: Informations sur Zend_Cache et APC
• Database: Liste des requêtes SQL avec les temps d’exécution
• Exception: Affichage des erreurs et des exceptions
• File: Liste de fichiers inclus et leurs tailles.
• Html: Nombre de fichiers CSS et Javascript associés à la page.
• Memory: Utilisation de la mémoire d’un contrôleur avec statistiques détaillées.
• Registry: Contenu de Zend_Registry
• Time: Temps d’exécution des actions du contrôleur
• Variables: Valeurs des variables et contenus des variables $_COOKIES et $_POST.

Nouvelle version de Zend Framework, elle corrige une quarantaine de bugs

Voici la liste issue de la changelog…

Bugs corrigés :

• [ZF-7605]: Zend_Application docs mistake
• [ZF-7550]: Bootstrap fails after checking out r17414
• [ZF-7417]: clarify confusion between ‘resource plugins’ and ‘resources’ in docs
• [ZF-7401]: Errors in QuickStart
• [ZF-7158]: No automatic creation of Zend_Application_Module_Autoloader for default module
• [ZF-7095]: Zend_Application_Resource_Modules Example is wrong
• [ZF-7091]: « scripts/load.sqlite.php » is missing « set_include_path »
• [ZF-6893]: Cannot use Zend_Application_Resource_FrontController to set baseurl for a subset of environments
• [ZF-6861]: Stripping all require_once calls makes Zend_Application unable to work
• [ZF-6803]: Zend_Application Default Module Bootstrap is Skipped
• [ZF-6679]: Items configured from Zend_Application::setOptions() via a config entry do not have their keys cast to lower case
• [ZF-6659]: Module bootstrap implementation
• [ZF-6634]: include warning with same module and namespace name
• [ZF-4730]: Add possibility to check group-membership in Zend_Auth_Adapter_Ldap
• [ZF-7358]: Zend_Cache_Backend_ZendServer_ShMem and Zend_Cache_Backend_ZendServer_Disk throws an exception in test()
• [ZF-7172]: How to instatiate the ZendServer cache backends
• [ZF-6291]: Zend_Cache::factory() denies creation of Zend_Cache_Backend_TwoLevels backend on Linux
• [ZF-5740]: Partial cleaning in Zend_Cache_Backend_TwoLevels::clean()
• [ZF-7589]: Zend_Date::setDate when parsing the date to set in an array
• [ZF-7554]: testSetLocale(Zend_DateTest) unit tests failure
• [ZF-7456]: Regression in 1.9 in ability to create Zend_Date from array
• [ZF-7454]: Timezone and Zend_Date
• [ZF-7647]: fetchAssoc() and fetchPairs() in Zend_Db_Adapter_Abstract have wrong docblock return type
• [ZF-7629]: Zend_Db_Adapter_Pdo_Mssql should pass @table_owner to sp_pkeys
• [ZF-5823]: Non-optimized SQL generated for LIMIT clause in MSSQL adapter
• [ZF-4251]: Zend_Db_Adapter_Pdo_Mssql doeas not support both LIMIT and DISTINCT in the same query
• [ZF-4099]: Zend_Db_Adapter_Pdo_Mssql – Order By in Limit Function
• [ZF-3434]: PDO_Mssql DSN includes _config['options']
• [ZF-3216]: Zend_Db_Adapter_Mysqli does not provide a proper way to catch MySQL error codes.
• [ZF-7549]: Missing prefix and type parameters in the PHPdoc for most of the addPrefixPath methods
• [ZF-7544]: Fatal Error when setting same FilterRule more than one time in script call
• [ZF-7135]: null values are treated as missing data instead of an empty value
• [ZF-7449]: Directive $element->setRegisterInArrayValidator(false) doesn’t work anymore
• [ZF-7208]: Incubator unit tests stop with fatal error ‘Class ‘Zend_Ldap_AllTests’ not found’
• [ZF-7604]: No Zend_Log_Writer_Syslog::setApplication() hence documentation
• [ZF-7614]: Incorrect function name in the #42.2 manual entry
• [ZF-7613]: There is not « factory » method in the Zend_Queue class
• [ZF-7560]: Zend_Translate_Adapter does not properly handle numeric key values
• [ZF-7648]: testNotSameMessageContainsTokenAndValue(Zend_Validate_IdenticalTest) unit tests failure
• [ZF-7643]: Empty token value in Zend_Validate_Identical::NOT_SAME
• [ZF-7631]: Zend_Validate_NotEmpty compatibility
• [ZF-7630]: Zend_Validate_Date doesn’t accept Zend_Date object
• [ZF-6457]: Zend_Validate_Date doesn’t validate a value filtered by Zend_Filter_LocalizedToNormalized
• [ZF-7597]: Reference guide minor error
• [ZF-7676]: Unit tests stop because of the « Call to undefined method Zend_XmlRpc_Server_Fault::getReturnValue() » fatal error

Il existe bien évidement celui de Zend qui est founit avec PHP, cela dit il existe également Xdebug qui est un excellent outil permettant de se configurer sur Eclipse pour faire du debug, d’améliorer les var_dump en PHP pour visualiser plus facilement les erreurs et de mettre en cache des données pour visualiser les performances de votre application.

Nous allons voir comment installer et configurer Xdebug dans votre environnement PHP.

Tout d’abord, il faut s’avoir que Xdebug est une extension à PHP (sous forme d’une DLL sous Windows, et d’un .so sous linux). Il faut récupérer l’extension sur le site de Xdebug : http://www.xdebug.org/ (vous pouvez essayer les paquets dans les dépôts sous linux c’est beaucoup plus pratique).

Il faut ensuite copier le fichier dans le répertoire des extensions :

Il faut ensuite activer l’extension dans le php.ini en rajoutant la ligne suivante :

extension=php_xdebug-2.0.4-5.2.8.dll

Xdebug est enfin installé sur le serveur php, la première chose que l’on peut remarque c’est que les var_dump sont beaucoup plus complets et lisibles que précédemment :

Les messages d’erreurs sont également plus complets :

On peut également utilisé Xdebug pour faire du profiling, c’est à dire faire un affichage de toutes les fonctions exécutées avec les temps de réponses. Pour cela il faut modifier le fichier php.ini et rajouter le code suivant dans la partie module settings :

[xdebug]
xdebug.profiler_enable=On
; On choisit le répertoire où on stocke le cache
xdebug.profiler_output_dir="c:\traces"
xdebug.profiler_append=On
xdebug.profiler_enable_trigger=On

Il faudra penser à vider le cache lorsqu’on veut profiler l’exécution d’une page en supprimer le fichier dans le répertoire.

On regarde ensuite le profilage avec un logiciel prévu à cet effet, il s’agit de WinCacheGrid sous Windows et XCacheGrid sous Linux, et on pourra avoir les résultats sous la forme suivante :

Pour une utilisation plus avancée, on peut aussi configurer Xdebug avec le PDT d’Eclipse pour avoir une vraie fonction de débogage perfectionnée ou sinon il reste aussi la solution ultime Zend Studio mais qui est relativement coûteuse.

On appelle cela une couche d’abstraction qui sert intermédiaire entre la base de données et l’application. Le but est de modéliser le schéma d’une base de données sous forme de classes et d’objet pour ne pas travailler avec le langage SQL et les drivers de base de données car il est évident qu’une application écrite de A à Z avec des mysql_connect() et mysql_query() ne sera pas très robuste et migrera difficilement vers un autre SGBD comme Postgre ou Oracle…

Zend_Framework fournit un outil nommé Zend_Db_Table pour gérer à l’aide d’un système de DAO (Database Access Object) les transactions avec les bases de données.

Nous allons voir dans un premier temps comment configurer Zend_Framework pour mettre en place ce système :

Configuration du fichier Application.ini :

;database configuration
resources.db.adapter = "pdo_mysql"
resources.db.params.host = "localhost"
resources.db.params.username = "root"
resources.db.params.password = ""
resources.db.params.dbname = "announcements"
resources.db.params.date_format = "YYYY-MM-ddTHH:mm:ss"
resources.db.isDefaultTableAdapter = true

Il faut spécifier dans le « Application.ini » les paramètres pour accéder à votre base de données, il faut y spécifier l’adresse de la base, le type (pdo_mysql, postgre, sqllite, oci8, mssql, …), l’utilisateur avec le mot de passe, le nom de la base de données et le format de date et heure.

Ecrire les classes d’accès aux données (utilisation de Zend_Db_Table) :

Il nous faut maintenant écrire les classes permettant de modéliser les tables de la base de données pour cela on va utiliser Zend_Db_Table pour générer une classe permettant d’accéder à la table « posts  » de notre application :

On créer tout d’abord un dossier « models » dans notre répertoire /application avec un dossier DbTable dedans.

Nous allons générer un fichier Post.php :

Tout d’abord, on crée une classe dérivée de Zend_Db_Table que l’on nommera avec la syntaxe suivante : Model_DbTablr_NomDeLaTable en spécifiant le nom extact dans l’attribut protégé « name » :

Ensuite il ne reste plus qu’à écrire les méthodes qui permet les transactions avec les bases de données, je recommende fortement d’utiliser une méthode pour chaque transaction plutôt que de les écrire dans le contrôleur, on est dans un design-pattern MVC !

Voici le prototypage de notre classe et l’implémentation de notre classe :

fetchRow('id = '.(int)$id);
		if (!$row)
		{
			// On lance une exception en cas d'erreur
			throw new Exception ("Erreur, l'enregistrement $id n'existe pas !");
		}
		// On retourne le résultat sous forme de tableau
		return $row->toArray();
	}

	/**
	 * Ajoute un article en base de données
	 * @param $values
	 * @return unknown_type
	 */
	public function addPost ($values)
	{
		// On enregistre les valeurs sous forme de tableau [champs] => valeur
		$result = $this->insert($values);
		if (!$result)
		{
			throw new Exception ("Erreur impossible d'enregister");
		}
	}

	/**
	 * Met à jour un article en base de donneés
	 * @param $values
	 * @return unknown_type
	 */
	public function updatePost ($id,$newValues)
	{
		$result = $this->update($newValues, 'id = '.(int)$id);
		if (!$result)
		{
			throw new Exception ("Erreur impossible de mettre à jour");
		}
	}

	/**
	 * Supprime l'article $id
	 * @param $id
	 * @return unknown_type
	 */
	public function removePost ($id)
	{
		$result = $this->delete('id = '.$id);
		if (!$result)
		{
			throw new Exception ("Erreur impossible de supprimer");
		}
	}

	/**
	 * Requête avec jointure pour récupérer les 5 premiers
	 * articles avec les données de la table auteur en jointure
	 * et qui ont leur status publié
	 * @return unknown_type
	 */
	public function findPostsWithAuthorsInformations ()
	{
		$db = $this->getAdapter();

		$select = $db->select()
					 ->from('post')
					 ->joinInner('author', 'post.author_id = author.id')
					 ->where('status = "published"')
					 ->limit(5);
		$query = $select->query();
                $result = $query->fetchAll();

		return $result;
	}
}
?>

Pour appeler cette classe dans le contrôleur rien de plus simple, on instancie un objet « $model » et pis on appelle les méthodes que l’on a implémentée :

< ?php
	class PostController extends Zend_Controller_Action
	{
		public function init ()
		{
			// On fait rien
		}

		public function testModelAction ()
		{
			$model = new Model_DbTable_Post();

			// Ajout
			$model->addPost(array('title' => 'test', 'content' => 'ceci est mon premier post', 'status' => 'publised'));

			// Requête
			$this->view->posts = $model->findPostsWithAuthorsInformations();

			// Suppression
			$model->removePost(2);

		}
	}
?>

La prochaine fois nous verrons le fonctionnement des formulaires avec Zend_Form

Doctrine ORM PHP 5 dors et déjà présent sur le framework Symfony, prépare une nouvelle version majeure du projet : Doctrine 2.0

Cette nouvelle version exclusivement compatible avec PHP 5.3 au minimum s’avère assez prometteuse et assez ambitieuse.

Petit rappel sur Doctrine : ce projet a été conçu tout comme Propel (basé sur Active Record) dans un but de créer un ORM relativement puissant et extrèmement riche en fonctionnalités : tests unitaires automatiser sur les classes relationnelles, schéma des bases en YML, génération de code automatique, système de cache avancé, plugins, gestion des contraintes d’intégrités avancée, load-balancing, profiler, outils de performances, validations des données en fonction du schéma, … Bref un véritable équivalent de Hibernate en PHP 5.

Le projet est principalement supporté par Sensio Labs (framework Symfony).

La prochaine version (Doctrine 2.0) sera basée sur PHP 5.3, elle utilisera les nouveaux drivers de PHP, et promet de véritable amélioration au niveau des performances.

Voici des benchmarks des performances de Doctrine 2.0 par rapport à sa version précédente :

PHP 5.2.8

#	Seconds	Memory
1	24	129170.648438 KB
2	23	129164.078125 KB
3	23	129176.851562 KB

PHP 5.3.0alpha4-dev

D’autre part, Doctrine deviendra beaucoup moins coûteux en code et sera moins verbeux.