Arne Blankerts travaille dans une agence de publicité allemande, SalesEmotion AdSolutions GmbH. Il rédige des articles pour PHP Magazin, ses sujets d'intérêt principaux étant XML et XUL.

Je ne suis resté que brièvement à cette session, puisqu'elle était très descriptive d'un aspect de PHP : l'utilisation d'XPath. C'est certes intéressant mais je préférais assister à la session sur les tests avec PHPT. Par conséquent, je risque de ne faire qu'une présentation sommaire...

XML est un format de document permettant de structurer des informations. C'est un conteneur de données.

XSL est un langage permettant d'écrire des feuilles de style pour XML. On utilise XSLT pour transformer des documents XML en d'autres formats (txt, HTML, etc.) ou XPath afin de parcourir le XML.

Mon collègue GrandFatherProfil Developpez de GrandFather vous a aimablement concocté un exemple d'utilisation d'XPath avec la méthode DOMDocument et son alternative SimpleXML...

<?xml version="1.0"?>
<schedule>
    <talk>
        <title>Exploring PHP - A language implementor's perspective</title>
        <speaker>Julian Dolby et Graeme Johnson</speaker>
        <time>9h00</time>
    </talk>
    <talk>
        <title>Filtering tainted data: PECL Input Filter vs. Zend_InputFilter</title>
        <speaker>Ben Ramsey</speaker>
        <time>9h00</time>
    </talk>
    <talk>
        <title>Keynote - How to combine PHP technology with Java based on enterprise systems</title>
        <speaker>Tim Bray</speaker>
        <time>12h00</time>
    </talk>
    <talk>
        <title>Maturing nicely - PHP-GTK 2</title>
        <speaker>Steph Fox</speaker>
        <time>13h00</time>
    </talk>
    <talk>
        <title>Confession time - Deadly sins using MySQL and PHP</title>
        <speaker>Arjen Lentz</speaker>
        <time>13h45</time>
    </talk>
    <talk>
        <title>Integration und Migration zu AJAX</title>
        <speaker>Gerd Schaufeldberger</speaker>
        <time>15h30</time>
    </talk>
</schedule>

$sample_xml = file_get_contents('schedule.xml');

echo 'Recherche avec parcours itératif avec DOM :<br/>';
$document = new DomDocument();
$document->loadXML($sample_xml);
$schedule = $document->documentElement;
foreach ($schedule->childNodes as $talk) {
    if ($talk->nodeType == XML_ELEMENT_NODE && $talk->tagName == 'talk')
    {
        $title = '';
        $speaker = '';
        foreach ($talk->childNodes as $child)
        {
            if ($child->nodeType == XML_ELEMENT_NODE && $child->tagName == 'title')
            {
                $title = $child->nodeValue;
            }
            
            if ($child->nodeType == XML_ELEMENT_NODE && $child->tagName == 'speaker')
            {
                $speaker = $child->nodeValue;
            }
        }

        if ($speaker == 'Tim Bray')
        {
            echo $title . '<br/>';
        }
    }
}
echo '<br/>';


echo 'Recherche avec accès direct aux noeuds par leur nom avec DOM :<br/>';
$document = new DomDocument();
$document->loadXML($sample_xml);
$speakers = $document->getElementsByTagName('speaker');
foreach ($speakers as $speaker) {
    if ($speaker->nodeValue == 'Tim Bray') {
        $talk = $speaker->parentNode;
        echo $talk->getElementsByTagName('title')->item(0)->nodeValue . '<br/>';
    }
}
echo '<br/>';

$sample_xml = file_get_contents('schedule.xml');

echo 'Recherche avec parcours itératif avec SimpleXML :<br/>';
$schedule = simplexml_load_string($sample_xml);
foreach ($schedule->talk as $talk) {
    if ($talk->speaker == 'Tim Bray')
    {
        echo $talk->title . '<br/>';
    }
}
echo '<br/>';


echo 'Recherche avec SimpleXML & XPath :<br/>';
$schedule = simplexml_load_string($sample_xml);
foreach ($schedule->xpath("/schedule/talk[speaker = 'Tim Bray']/title") as $title)
{
    echo $title . '<br/>';
}
?>

Nous allons utiliser le langage XPath dans notre feuille XSLT afin de transformer un document XML en document HTML.

XML + XSLT = HTML

L'idée ici n'est pas de rechercher un élément, comme nous avons fait dans les exemples précédents, mais d'utiliser XSL pour transformer un fichier de données XML en une page Web.

Reprenez le schedule.xml ci-dessus et créez les fichiers suivants (largement inspirés de ceux proposés sur php.net/xsl) :

<?xml version="1.0"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:param name="date" select="'8 novembre'"/>
    <xsl:output method="html" encoding="iso-8859-1" indent="no"/>
    <xsl:template match="schedule">
        Voici la liste des sessions du <xsl:value-of select="$date"/>
        <xsl:apply-templates/>
    </xsl:template>
    <xsl:template match="talk">
        <h3><xsl:value-of select="title"/></h3>
        <h4>by <xsl:value-of select="speaker"/> (<xsl:value-of select="time"/>)</h4>
        <hr />
    </xsl:template>
</xsl:stylesheet>

<?php

$input = new DOMDocument();
$xsl = new XSLTProcessor();

$input->load('schedule-html.xslt');
$xsl->importStyleSheet($input);

$input->load('schedule.xml');
echo $xsl->transformToXML($input);

?>

Chargez le script PHP, vous obtiendrez une page HTML bien présentée contenant les informations du XML.

Pour de petites bases de données, XML est un format intéressant car il est à la fois lisible et utilisable.

Avec XPath et SimpleXML, il est possible de rechercher des informations de manière relativement simple et avec une utilisation de ressources souvent moins importante que dans le cas d'une base de données.

Ne négligez pas XML et XPath.

Marcus Börger, alias helly, est actif dans les communautés PHPLa SPL décrite par Marcus, PECLSite de Marcus chez PECL, Zend. Il est l'un des développeurs du noyau de PHP.

Comment sont testées les fonctions internes à PHP ? Comment savoir si un script PHP s'exécute comme il le devrait ?

L'idée de PHPT est simple : écrire des fichiers de test selon un format spécifique. Un script PHP exécute le test et compare le flux envoyé à la sortie standard avec la portion spécifiée dans le fichier de test. Le résultat de cette comparaison détermine la qualité du script.

C'est très simple, il s'agit d'un script PHP. Téléchargez le source de votre version de PHP (php.net/downloads.php) et observez bien : vous verrez un script "run-tests.php" dans la racine de l'archive, ainsi qu'un répertoire "tests" contenant de nombreux fichiers ayant une extension ".phpt" : ce sont les tests utilisés pour tester la validité d'un script PHP.

À l'aide des lignes de commandes, l'objectif est d'exécuter le script run-tests.php et d'en observer la sortie.

--TEST--
Hello World
--FILE--
<?php echo "Hello World"; ?>
--EXPECT--
Hello World

--TEST--
Hello World
--FILE--
<?php echo "Hello World
--EXPECTF--
Parse error: syntax error, unexpected $end in %s.php on line %d

Placez ces scripts dans le répertoire de run-tests.php puis lancez la commande suivante :

php run-tests.php

N'ayant pas essayé moi-même, je ne m'aventurerai pas davantage. Il me semble tout de même qu'il faut déclarer une variable d'environnement TEST_PHP_EXECUTABLE pour donner le chemin jusqu'à PHP.

Cette méthode de test fonctionne uniquement pour les scripts ayant une sortie. Cependant, il devient complexe de tester les scripts ne générant aucune sortie. C'est par exemple le cas de l'ensemble des classes : il est impossible de tester directement une classe, il faut donc écrire le test pour un scrit utilisant la classe. C'est cette limite qui m'a poussé à ne pas tester PHPT plus amplement.

J'estime que la méthode PHPT est très efficace et très pratique pour de petits tests, comme par exemple le retour d'une fonction. Pour de plus amples utilisations de PHP, je ne sais pas s'il faut recommander PHPT (mais je peux me tromper, auquel cas je vous serais reconnaissant de me le faire savoir).

En résumé, j'ai l'impression que l'écriture de tests est un procédé complexe et qui est encore largement sujet à erreurs...

Cependant, si l'on développe en fonction des tests (plutôt que d'écrire les tests en fonction de ce qui est développé), c'est-à-dire si on utilise la méthode connue en tant que "test-driven development", alors l'exécution de tests à la PHPT prend tout son sens.

Derrière son air vaguement timide, Arne est quelqu'un de bien sympatique et qui connaît son sujet. Je n'ai malheureusement pas pu rester jusqu'au bout de la présentation, ainsi je ne vous en donne ici qu'un aperçu ingrat (car incomplet).

La phrase que je retiens : "PHP 4 is dead".

• AJAX tue le référencement ;
• AJAX n'a pas fondamentalement besoin d'XML (JSON est possible aussi)

Décompressez le répertoire "ajax" de l'archive dans un répertoire de votre serveur Web et appelez le fichier "demo.html" : vous verrez apparaître un message donné par le script "echo.php". Nous pourrions imaginer ici d'utiliser une base de données pour afficher une chaîne en fonction d'un paramètre... Il suffit d'avoir un peu d'imagination.

Appelez maintenant la page "suggest.html" et tapez une lettre, par exemple "s" : AJAX permet de faire des suggestions de mots.

Enfin, chargez la page d'index et utilisez les boutons "précédent" et "suivant".

AJAX, c'est bien.

AJAX, c'est à utiliser avec précaution.

L'exemple de la galerie est typique de ce qu'il ne faut pas faire, sous peine de ne pas être référencé. En effet, puisque les moteurs de recherche ne comprennent pas le JavaScript, ils sont incapables de voir toutes les informations accessibles par AJAX. Ici, il s'agit par exemple des descriptions des photos.

Si vous souhaitez en savoir davantage sur AJAX, n'hésitez pas à consulter notre page de cours AJAX et particulièrement (pour compléter l'exemple des suggestions) le tutoriel par Denis Cabasson : AJAX - Une autocomplétion pas-à-pas. Si c'est le référencement auprès des moteurs de recherche qui vous intéresse, rendez-vous dans nos cours de webmarketing.

Derick Rethans travaille actuellement comme chef du projet eZ components pour eZ systems A.S. Il a contribué à PHP au travers d'extensions comme Date et InputFilter, en plus de diriger le groupe QA (cf. la session de tests présentée plus tôt dans la matinée par Marcus Börger). Il travaille également sur Xdebug.

L'idée principale est que PHP 6 supportera Unicode à tous les niveaux. Les chaînes seront encodées (en nterne) en UTF-16, ce qui permet aux développeurs d'écrire leur code avec l'alphabet de leur choix (ce que je ne recommande absolument pas, au passage). Vous pouvez voir un cas extrême en photo ci-dessus...

La bibliothèque ICU sera utilisée par PHP 6 pour gérer tout Unicode.

Pour gérer la compatibilité descendante, il sera possible d'utiliser une directive du php.ini pour définir l'encodage par défaut. En effet, les scripts seront maintenant considérés UTF-16 donc chaque caractère sera sur 2 octets. PHP 6 ne gère plus les flux comme des octets ("code units") mais comme des caractères ("code points", chacun de 2 octets).

declare(encoding="utf-8");

Je sens que nous allons bien nous amuser, puisque l'encodage de sortie (unicode.output_encoding) peut être différent de l'encodage du script (unicode.script_encoding), de l'encodage "runtime" (unicode.runtime_encoding) ainsi que de l'encodage géré par le navigateur (default_charset)... Tout cela étant encore différent de l'encodage interne de PHP, qui est UTF-16...

Voyons un exemple pour illustrer ces conflits.

declare(encoding="iso-8859-1");
ini_set('unicode.output_encoding', 'utf-8');
$str = "r&#248;dbærsyltet&#248;y<br/>";
$bstr = b"r&#248;dbærsyltet&#248;y<br/>";
echo $str, $bstr;

Note : Le code ci-dessus devrait afficher deux lignes de texte différentes, puisque d'une part le caractère "ø" n'existe pas dans le jeu de caractères "iso-8859-1" et, d'autre part, le "b" situé juste avant le guillemet oblige PHP à traiter la chaîne en tant que chaîne "binaire", donc à ne pas tenir compte de l'encodage défini avec le mot-clef "declare" au début du script. Ainsi, le premier affichage devrait se faire à l'aide du jeu de caractères "iso-8859-1" tandis que le second affichage utilise "UTF-8". Je viens d'essayer sur ma machine de test, les deux lignes sont identiques... Je prévois des casse-têtes même pour déterminer pourquoi un code fonctionne alors qu'il ne le devrait pas ! Je soupçonne mon Windows de s'être adapté sans me le dire...

rødbærsyltetøy
rødbærsyltetøy

PHP 6 est actuellement en développement. Une première version "RC" (release candidate) devrait sortir avant la fin de l'année 2006.

Si vous souhaitez découvrir PHP 6 tout en conservant la possiblité d'utiliser PHP 5, je vous recommande la lecture de ce tutoriel : Alterner entre plusieurs versions d'Apache et de PHP.

Dustin Whittle travaille en freelance comme consultant en technologie. Il est actif dans a communauté PHP principalement au sein du projet symfony, pour lequel il propose des améliorations et des corrections.

symfony est un projet d'origine française. C'est un framework complet pour des applications Web et il est développé en PHP 5.

• L'administration du projet ;
• La génération de code ;
• Les tests ;
• La documentation ;
• Le déploiement.

• LIME : Tests ;
• Creole : Abstraction de bases de données ;
• PHPMailer : Envoi d'e-mails ;
• Prototype : Framework JavaScript ;
• TinyMCE : Édition avancée de texte ;
• DynArch.com : Calendrier ;
• etc.

symfony suit une architecture MVC : sfPropel est le modèle, sfView est la vue et sfAction le contrôleur.

D'autres Pattern Design sont proposés : sfContext est un Singleton, sfFeed est une Factory...

Vous l'aurez compris, ce ne serait pas rendre justice à symfony que le présenter ici en 20 lignes de code.

Je vous recommande de vous rendre sur le site officiel et de consulter la documentation sur le projet Askeet.

Ce qui me plaît le plus avec ce projet est le fait qu'il soit résolument PHP 5.

Matthew Peters travaille actuellement pour IBM à Hursley, Royaume Uni. Il a contribué au projet SDO, distribué en PECL.

Un composant (component) est une classe qui implémente la logique de l'application, c'est-à-dire le déroulement des actions.

Des interfaces, appelées services, mettent à disposition les possibilités des composants.

Des références sont des interfaces orientées services (c'est donc la même chose que ci-dessus) proposant des fonctions d'autres composants. Il s'agit donc de sortes de services Web destinés à un usage interne (non à travers le Web).

• L'implémentation (développement) des composants qui proposent leurs fonctions ;
• La liaison des composants et des références de manière à construire les services.

L'implémentation est de la programmation orientée objet classique.

La liaison est le point que j'ai trouvé particulièrement intéressant. L'idée est d'éviter de mélanger les couches : la logique applicative et le reste. Ce mélange est considéré comme inévitable la plupart du temps, car en effet il y aura toujours besoin à un moment de demander à PHP d'inclure et de gérer les autres modules de l'application.

La solution apportée par SCA est d'effectuer cette liaison dans les commentaires du code. J'ai trouvé l'idée quelque peu étrange mais néanmoins excellente. En utilisant les commentaires, nous n'avons aucune liaison dans le code PHP. Comme le dit le PDF de la session : "la liaison est déclarative, dans les commentaires ; la logique applicative est impérative, dans le code".

Les composants SCA exposés en tant que WebServices peuvent être utilisés par n'importe quel client SOAP, sans qu'ils aient besoin de savoir qu'il s'agit de SCA. Inversement, les composants SCA peuvent utiliser des WebServices sans avoir besoin de savoir s'il s'agit de composants SCA.

Voici une approche très intéressante qui peut profiter aux grosses applications, qu'il s'agisse ou non de WebServices.

Karl Heinz Marbaise travaille avec de nombreux outils open source : CMS, e-commerce, etc., aussi bien PHP que Java.

SimpleTest est un framework de test pour PHP.

Le principe est de dériver les classes fondamentales de SimpleTest afin de les faire correspondre à votre utilisation. Dans vos classes dérivées, vous devez implémenter les tests au moyen d'assertions (assert...()) permettant de vérifier la validité de votre code.

C'est plus performant que PHPT dans la mesure à vous avez davantage de contrôle, vous pouvez tester davantage de choses. C'est aussi plus long à mettre en place puisque les tests sont eux-mêmes des classes qui peuvent avoir leurs bugs...

Je vous propose l'exemple du site de SimpleTest comme démonstration (attention, à exécuter avec PHP 4) :

<?php

class Log
{    
    var $file;

    function Log($string)
    {
        $this->file = $string;
    }

    function message($string)
    {
        $mode = 'a';
        $handle = fopen($this->file, $mode);

        if ($handle !== FALSE)
        {
            fwrite($handle, $string);
            fclose($handle);
        }
    }
}

?>

<?php

require_once('simpletest/unit_tester.php'); // classe SimpleTest utilisée
require_once('simpletest/reporter.php'); // pour afficher le rapport
require('Log.php'); // la classe à tester

class LoggingTest extends UnitTestCase {    
    function testCreatingNewFile() {
        @unlink('./test.log');
        $log = new Log('./test.log');
        $this->assertFalse(file_exists('./test.log'));
        $log->message('Should write this to a file');
        $this->assertTrue(file_exists('./test.log'));
    }
}

$test = &new LoggingTest();
$test->run(new HtmlReporter());

?>

Suivant les droits d'accès à votre répertoire, le résultat sera différent.

Bien qu'écrit en PHP 4, SimpleTest est un framework assez pratique. Le souci majeur est d'apprendre à utiliser les classes.

Pour information, PHPEditTest logiciel : l'EDI PHPEdit et EclipseTest logiciel : l'IDE Eclipse permettent tous deux d'écrire rapidement des scripts pour SimpleTest (Eclipse nécessite un plugin, tandis que PHPEdit le permet en natif).

De mon point de vue, le gros souci est que la version PHP 5 de SimpleTest n'est pas encore publiée. S'il faut commencer par réécrire le code du framework pour pouvoir l'utiliser sans problème, nous perdons en efficacité...