Monthly Archives

6 Articles

Ubuntu 10.04 enfin disponible

Et oui ça y est, Ubuntu Lucid Lynx est enfin sorti. J’ai pu le télécharger hier soir vers 19h45 (pile pour la sortie finale). L’installation a totalement évoluée afin d’être accessible facilement à un maximum de personnes (même si la partie gestion des disques est à revoir).

Le nouveau thème donne une seconde jeunesse à la distribution Ubuntu. Certains aiment, d’autres pas. Mis à par ça, cette nouvelle version intègre la gestion de ses différents comptes sociaux (facebook, twitter, …), l’accès à un espace de stockage en ligne de 2Go grâce à Ubuntu One (existait déjà dans la 9.10).

Point important, le temps de chargement a été revu. Pour moi, sur une machine d’il y a 6ans (Athlon 64 3000+ 1Go de RAM), je mets 10s à arriver sur l’écran de connexion et 2s pour arriver sur le bureau.

De plus, la version 10.04 est une LTS, ce qui veut dire que la durée de support est plus longue que les autres. Elle se terminera le 29 avril 2013 (ou 21 décembre 2012 s’il y a la fin du monde).

Bref, n’attendez plus, rendez-vous directement sur le site officiel pour télécharger cette distribution.

Introduction au ZF – Partie 5 : Doctrine

Introduction au ZF – Partie 5 : Doctrine

Pour les Models, je pensais vous montrer l’exemple concret de l’usine à gaz présentée par Zend. Mais vu que le Zend Framework 2.0 va le changer pour doctrine, j’ai décidé de passer dessus. Doctrine a plusieurs points positifs :

  • Il utilise PDO donc il y a toujours une couche d’abstraction
  • Il génère automatiquement les models (si on utilise l’utilitaire)
  • Il est plus performant que Zend_Db
  • Tout est objet
  • Conforme au pattern MVC

Pour ces raisons, Doctrine semble être le choix le plus judicieux. Maintenant il ne reste plus qu’à l’intégrer à notre projet. Pour informations, j’utilise la version 1.2.2 de Doctrine qui est la dernière version stable en date. Vous pouvez la récupérer à cette adresse.

Je vous conseil aussi d’avoir la documentation officielle sous le bras pour bien comprendre tout ce qu’il va se dire ici. Avant de continuer, voici la base de donnée finale que nous allons utiliser tout au long de ce tutoriel. Je mets le contenu final ici pour que l’on génère les Models complets dès le début.

C’est avec une application bien pensée qu’on arrive à un bon résultat.

Et voici maintenant le script avec un utilisateur par défaut. Le mot de passe décrypté est azerty.

SET SQL_MODE="NO_AUTO_VALUE_ON_ZERO";

/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
/*!40101 SET NAMES utf8 */;

--
-- Base de données: `tutosite`
--
CREATE DATABASE `tutosite` DEFAULT CHARACTER SET utf8 COLLATE utf8_general_ci;
USE `tutosite`;

-- --------------------------------------------------------
--
-- Structure de la table `article`
--

CREATE TABLE IF NOT EXISTS `article` (
  `idArticle` int(11) NOT NULL AUTO_INCREMENT,
  `idUtilisateur` int(11) NOT NULL,
  `idRubrique` int(11) NOT NULL,
  `titre` varchar(45) NOT NULL,
  `corps` text NOT NULL,
  `date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`idArticle`),
  KEY `fk_Article_Utilisateurs` (`idUtilisateur`),
  KEY `fk_Article_Rubrique` (`idRubrique`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

--
-- Contenu de la table `article`
--
-- --------------------------------------------------------
--
-- Structure de la table `commentaire`
--

CREATE TABLE IF NOT EXISTS `commentaire` (
  `idCommentaire` int(11) NOT NULL AUTO_INCREMENT,
  `idArticle` int(11) NOT NULL,
  `pseudo` varchar(45) NOT NULL,
  `email` varchar(45) DEFAULT NULL,
  `message` text NOT NULL,
  `date` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`idCommentaire`),
  KEY `fk_Commentaire_Article` (`idArticle`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;

--
-- Contenu de la table `commentaire`
--
-- --------------------------------------------------------
--
-- Structure de la table `rubrique`
--

CREATE TABLE IF NOT EXISTS `rubrique` (
  `idRubrique` int(11) NOT NULL,
  `Nom` varchar(45) NOT NULL,
  PRIMARY KEY (`idRubrique`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Contenu de la table `rubrique`
--
-- --------------------------------------------------------
--
-- Structure de la table `tag`
--

CREATE TABLE IF NOT EXISTS `tag` (
  `idTag` int(11) NOT NULL,
  `Nom` varchar(45) NOT NULL,
  `Couleur` varchar(7) NOT NULL DEFAULT '#000000',
  `Hicolor` varchar(7) NOT NULL DEFAULT '#000000',
  PRIMARY KEY (`idTag`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

--
-- Contenu de la table `tag`
--
-- --------------------------------------------------------
--
-- Structure de la table `tagarticle`
--

CREATE TABLE IF NOT EXISTS `tagarticle` (
  `idTag` int(11) NOT NULL,
  `idArticle` int(11) NOT NULL,
  PRIMARY KEY (`idTag`,`idArticle`),
  KEY `fk_Tag_has_Article_Tag` (`idTag`),
  KEY `fk_Tag_has_Article_Article` (`idArticle`)
) ENGINE=MyISAM DEFAULT CHARSET=utf8;

--
-- Contenu de la table `tagarticle`
--
-- --------------------------------------------------------
--
-- Structure de la table `utilisateurs`
--

CREATE TABLE IF NOT EXISTS `utilisateurs` (
  `idutilisateur` int(11) NOT NULL AUTO_INCREMENT,
  `login` varchar(50) NOT NULL,
  `passwd` varchar(100) NOT NULL,
  PRIMARY KEY (`idutilisateur`)
) ENGINE=InnoDB  DEFAULT CHARSET=utf8 AUTO_INCREMENT=2 ;

--
-- Contenu de la table `utilisateurs`
--

INSERT INTO `utilisateurs` (`idutilisateur`, `login`, `passwd`) VALUES
(1, 'admin', 'ab4f63f9ac65152575886860dde480a1 ');

--
-- Contraintes pour les tables exportées
--
--
-- Contraintes pour la table `article`
--
ALTER TABLE `article`
  ADD CONSTRAINT `fk_Article_Rubrique` FOREIGN KEY (`idRubrique`) REFERENCES `rubrique` (`idRubrique`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  ADD CONSTRAINT `fk_Article_Utilisateurs` FOREIGN KEY (`idUtilisateur`) REFERENCES `utilisateurs` (`idutilisateur`) ON DELETE NO ACTION ON UPDATE NO ACTION;
--
-- Contraintes pour la table `commentaire`
--
ALTER TABLE `commentaire`
  ADD CONSTRAINT `fk_Commentaire_Article` FOREIGN KEY (`idArticle`) REFERENCES `article` (`idArticle`) ON DELETE NO ACTION ON UPDATE NO ACTION;

Voilà pour la partie base de données SQL. Maintenant nous allons nous attaquer à la configuration. Nous allons tout d’abord créer les répertoires suivants :

  • Dossier contenant les données des tables en script YAML générés par Doctrine /application/configurations/data/fixtures
  • Dossier contenant les scripts SQL générés par Doctrine /application/configurations/data/sql
  • Dossier de migration de la base de données /application/configurations/migration
  • Dossier contenant le script de génération des cmodels /application/scripts
  • Dossier contenant nos models générés /library/App/Models

Quand la création des dossiers est faite, vous allez télécharger Doctrine 1.2.2. La version sandbox est inutile ici vu que les scripts donnés pour la génération doivent être complètement refait pour Zend.

Lorsque vous avez téléchargé Doctrine, vous allez extraire son contenu dans /library. Vous devriez alors avoir le dossier /library comme la capture sur votre droite. Le dossier vendor permet d’utiliser les scripts YAML quand au dossier Doctrine, il contient tout le cœur de Doctrine.

Maintenant que Doctrine a été correctement ajouté au dossier Library, Que la base de donnée a bien été ajoutée au SGBD, nous pouvons passer à la suite qui va consister à configurer proprement Zend.

Tout d’abord, nous allons rajouter les lignes suivantes au fichier /application/configurations/app.ini

; ---
; Doctrine
; ---

; configuration de base
; Le dsn correspond aux infos de connexion. Ici nous appelons une base mysql
; SGBD : MySqL
; Login : Root
; Password : azerty //si aucun password mettre juste root@localhost/bdd
; Serveur : localhost
; BDD : tutosite
doctrine.dsn                = "mysql://root:azerty@localhost/tutosite"
doctrine.data_fixtures_path = APPLICATION_PATH "/configurations/data/fixtures"
doctrine.sql_path           = APPLICATION_PATH "/configurations/data/sql"
doctrine.migrations_path    = APPLICATION_PATH "/configurations/migrations"
doctrine.yaml_schema_path   = APPLICATION_PATH "/configurations/schema.yml"
doctrine.models_path = APPLICATION_PATH "/../library/App/Models"

; règles lors de la génération des classes
; on utilise la convention de nommage PEAR
doctrine.generate_models_options.pearStyle  = true
; on génère les classes de table
doctrine.generate_models_options.generateTableClasses  = true
; on génère les classes de base. Ces classes contiennent les définitions de nos tables
doctrine.generate_models_options.generateBaseClasses  = true
; on définit un préfixe pour les classes de base
doctrine.generate_models_options.baseClassPrefix  = "Base_"
; on ne pet rien ici, avec la convention pear, ils seront ajoutés dans le sous dossier Base
doctrine.generate_models_options.baseClassesDirectory  =
; on ne met pas le préfixe au nom de fichier
doctrine.generate_models_options.classPrefixFiles  = false
; toutes les classes commenceront par ce préfixe
doctrine.generate_models_options.classPrefix = "App_Models_"

Ensuite, nous allons nous intéresser au /application/Bootstrap.php et nous allons ajouter la fonction d’initialisation de Doctrine :

protected function _initDoctrine() 
{
    //on met Doctrine en autoload
    $this->getApplication()
         ->getAutoloader()
         ->pushAutoloader ( array ('Doctrine', 'autoload' ) );
    spl_autoload_register(array('Doctrine', 'modelsAutoload'));

    //on récupère une instance de Doctrine
    $manager = Doctrine_Manager::getInstance ();

    //permet de valider automatiquement l'intégrité des données
    //ce qui veut dire que l'on ne peut pas mettre une variable de type string
    //dans une variable de type int.
    $manager->setAttribute (Doctrine::ATTR_VALIDATE, Doctrine::VALIDATE_ALL);
    //l’AUTO_ACCESSOR_OVERRIDE va nous permettre de personnaliser l’assignation de données.
    $manager->setAttribute ( Doctrine::ATTR_AUTO_ACCESSOR_OVERRIDE, true );
    //Doctrine permet de personnaliser également les classes de table en permettant 
    //de créer des méthodes propres à une table. 
    //Ce paramètre permet de charger le fichier contenant nos méthodes personnalisées.
    $manager->setAttribute (
     Doctrine::ATTR_MODEL_LOADING, 
     Doctrine::MODEL_LOADING_CONSERVATIVE
    );
    //on permet le chargement des classes table
    $manager->setAttribute ( Doctrine::ATTR_AUTOLOAD_TABLE_CLASSES, true );

    //on récupère toutes les options doctrine du fichier app.ini
    $doctrineConfig = $this->getOption('doctrine');

    //on récupère la variable doctrine.models_path du fichier app.ini
    //afin d'avoir le répertoire des models
    //pour que Doctrine les charge
    Doctrine::loadModels($doctrineConfig['models_path']);

    //on récupère la connexion à mysql et on la nomme doctrine
    $conn = Doctrine_Manager::connection($doctrineConfig['dsn'],'doctrine');
    //je sais plus ce que sa veut dire, mais il le faut
    $conn->setAttribute(Doctrine::ATTR_USE_NATIVE_ENUM,true);

    //on définit la sortie encodée en UTF-8
    $conn->setCharset('utf8');
    $conn->setCollate('utf8_general_ci');

    //on retourne la connexion
    return $conn;
}

Et pour que tout soit chargé directement, il suffit d’ajouter ces lignes dans la fonction _initNamSpaces() :

$autoloader->registerNamespace('Doctrine_');
$autoloader->registerNamespace('Doctrine');

Bien, maintenant Doctrine est correctement intégré à notre framework. Il ne reste plus qu’à générer les classes. Pour ce faire, il nous fait le fichier script suivant /application/scripts/Doctrine.php :

// Define path to application directory
defined('APPLICATION_PATH')
    || define('APPLICATION_PATH',
              realpath(dirname(__FILE__) . '/..'));

// Define application environment
defined('APPLICATION_ENV')
    || define('APPLICATION_ENV',
              (getenv('APPLICATION_ENV') ? getenv('APPLICATION_ENV')
                                         : 'production'));

// Typically, you will also want to add your library/ directory
// to the include_path, particularly if it contains your ZF install
set_include_path(implode(PATH_SEPARATOR, array(
    realpath(APPLICATION_PATH . '/../library'),
    get_include_path(),
)));

require_once 'Doctrine.php';

/** Zend_Application */
require_once 'Zend/Application.php';

// Create application, bootstrap, and run
$application = new Zend_Application(
    APPLICATION_ENV,
    APPLICATION_PATH . '/configurations/app.ini'
);

$application->getBootstrap()->bootstrap('doctrine');
$config = $application->getOption('doctrine');

$cli = new Doctrine_Cli($config);
$cli->run($_SERVER['argv']);

Vous l’aurez sans doute deviné, il s’agit du fichier /public/index.php avec à la fin l’instanciation de Doctrine. Cette instanciation nous permet d’utiliser, par le biais de la ligne de commande, Doctrine et, ainsi, générer nos classes.

Pour ce faire, allez dans votre invite de commande et rendez vous dans le dossier qui contient le script. Tapez juste la commande suivante :

php Doctrine.php

Elle devrait vous retourner le résultat suivant :

Il ne nous reste plus qu’à taper la commande :

php doctrine.php generate-models-db
php doctrine.php generate-yaml-db

Dans le dossier /application/configurations/ nous trouverons le dossier schema.yml contenant le script YAML de notre base de données. Et maintenant, si nous regardons dans le dossier /library/App/Models, nous avons pleins de classes de créées.

Prenons par exemple la table Utilisateurs. Elle aura 3 classes dédiées :

  • App_Models_Utilisateurs : permet de définir des fonction sur un objet utilisateur
  • App_Models_UtilisateursTable : permet de définir les différentes requêtes à faire sur notre table
  • App_Models_Base_Utilisateurs : contient la définition de la table Utilisateurs.

Justement, afin de tester et de bien comprendre ces classes, nous allons ajouter une fonction à la classe App_Models_UtilisateursTable. La fonction en question n’est rien d’autre qu’un fetchAll permettant de faire un Select de base.

/**
 * Select de base
 * 
 * @param string $where
 * @param string $order
 * @param int $limit
 * @param int $offset
 * @return Collection
 */
 public function fetchAll($where=null, $order=null, $limit=null, $offset=null)
 {
     $select = Doctrine_Query::create()->select('*')
         //dans le from on met le nom de la classe
         //Doctrine s'occupe du reste
         ->from('App_Models_Utilisateurs');

     if(isset($where)){ $select->where($where); }
     if(isset($order)){ $select->orderBy($order); }
     if(isset($limit)){ $select->limit($limit); }
     if(isset($offset)){ $select->offset($offset); }

     return $select->execute();
 }

Ensuite pour utiliser cette requête, nous allons éditier le controller Admin_AccueilController. Dans d’action d’index ajoutez les lignes suivantes :

//on récupère la classe table de App_Models_Utilisateurs
$table = Doctrine_Core::getTable('App_Models_Utilisateurs');
//on liste tout le monde
$liste = $table->fetchAll();
//on traite le résultat
foreach($liste as $unuser)
{
    print_r($unuser->login);
    print_r($unuser->passwd);
}

Normalement, si vous vous rendez sur la page concernée, vous devriez voir afficher le login et le mot de passe des utilisateurs. Voilà, maintenant vous pouvez utiliser Doctrine au sein du Framework Zend. La prochaine fois, nous verrons la création des premiers articles de notre Blog.

Installation de PHP 5.2 dotdeb sur Ubuntu

Installation de PHP 5.2 dotdeb sur Ubuntu

by Throrïn 0 Comments

Aujourd’hui je vais vous faire résoudre un problème récurent que j’ai eu sur mes serveurs. L’installation de PHP 5.2.13 sur Ubuntu en utilisant les paquets dotdeb.

Pourquoi passer par ces paquets ? Et bien c’est plus simple que de compiler soit même PHP et ça évite d’oublier des dépendances. Le problème des paquets dotdeb c’est qu’ils sont prévus pour Debian or, Ubuntu utilise des Library avec quelquefois des noms différents. Je vais donc vous expliquer pas à pas l’installation de cette version.

Cette procédure ne marche plus à partir d’Ubuntu 10.04 LTS. D’un car les dépendances ne sont plus disponibles, de deux car une version plus récente de PHP est disponible.

Tout d’abord, il vous faut ajouter les sources APT pour installer tout un serveur LAMP @dotdeb dans le fichier /etc/apt/sources.list:

deb http://packages.dotdeb.org stable all 
deb-src http://packages.dotdeb.org stable all

Ensuite, il vous faudra installer apache :

sudo aptitude install apache2 apache2-mpm-prefork apache2-prefork-dev apache2-utils apache2.2-common

Ensuite, si nécessaire, installez le serveur MySQL qui va bien:

sudo aptitude install mysql-client mysql-client-5.1 mysql-common mysql-server mysql-server-5.1 mysql-server-core-5.1

Pour finir nous allons installer toutes les Library requises pour l’installation de PHP.

sudo aptitude install libtidy-dev curl libcurl4-openssl-dev libcurl3 libcurl3-gnutls zlib1g zlib1g-dev libxslt1-dev libzip-dev libzip1 libxml2 libsnmp-base libsnmp15 libxml2-dev libsnmp-dev libjpeg62 libjpeg62-dev libpng12-0 libpng12-dev zlib1g zlib1g-dev libfreetype6 libfreetype6-dev libbz2-dev libxpm4-dev libmcrypt-dev libmcrypt4

Voilà. Malgré tout, il nous faut installer 3 Library introuvables par aptitude mais nécessaires à l’installation des paquets dotdeb. Nous récupérons les fichiers nécessaires avec l’utilitaire wget.

32bits:

wget http://us.archive.ubuntu.com/ubuntu/pool/main/k/krb5/libkrb53_1.6.dfsg.4~beta1-5ubuntu2_i386.deb
wget http://us.archive.ubuntu.com/ubuntu/pool/main/i/icu/libicu38_3.8-6ubuntu0.2_i386.deb
wget http://mirrors.kernel.org/ubuntu/pool/main/libt/libtool/libltdl3_1.5.26-1ubuntu1_i386.deb

64bits:

wget http://us.archive.ubuntu.com/ubuntu/pool/main/k/krb5/libkrb53_1.6.dfsg.4~beta1-5ubuntu2_amd64.deb
wget us.archive.ubuntu.com/ubuntu/pool/main/i/icu/libicu38_3.8-6ubuntu0.2_amd64.deb
wget http://mirrors.kernel.org/ubuntu/pool/main/libt/libtool/libltdl3_1.5.26-1ubuntu1_amd64.deb

Et nous installons les différents fichiers :

32bits:

sudo dpkg -i libkrb53_1.6.dfsg.4~beta1-5ubuntu2_i386.deb
sudo dpkg -i libicu38_3.8-6ubuntu0.2_i386.deb
sudo dpkg -i libltdl3_1.5.26-1ubuntu1_i386.deb

64bits:

sudo dpkg -i libkrb53_1.6.dfsg.4~beta1-5ubuntu2_amd64.deb
sudo dpkg -i libicu38_3.8-6ubuntu0.2_amd64.deb
sudo dpkg -i libltdl3_1.5.26-1ubuntu1_amd64.deb

Et voilà, il n’y a plus qu’à installer PHP :

sudo apt-get update
sudo apt-get install php5

Rajoutez les extensions utiles :

sudo apt-get install php5-apc php5-curl php5-gd php5-mcrypt php5-mhash php-pear php5-mysql

Voilà, maintenant vous avez un serveur LAMP fonctionnel avec PHP 5.2.13.

Complément Zend_Auth et Zend_Session

Complément Zend_Auth et Zend_Session

Je viens de voir que j’ai oublié de vous parler de la variable de session créée lors de l’identification. Il faut savoir que Zend gère les variables de session de façon sécurisée. Autant vous pouvez en PHP standard modifier vos données avec un $_SESSION[“foo“], autant avec Zend, ces données sont sauvegardées dans un objet protégé qui lui, est stocké dans $_SESSION.

Pour vous faire une idée, vous ne pouvez pas modifier accidentellement une donnée. Il faudra absolument passer par la classe Zend_Session pour les modifier.

Enfin, ici je vais vous montrer comment modifier le contenu di site en fonction de la connexion d’un visiteur. S’il est connecté, des menus apparaîtrons, sinon, d’autres seront présents.

Maintenant que l’introduction est finie, je vais juste vous faire faire une chose supplémentaire au tutoriel d’identification.

Quand le visiteur est déconnecté, le lien ‘identifiez-vous’ apparaît. Quand il est connecté, ce lien sera remplacé par ‘déconnexion’. Tout ceci va se jouer dans la fichier header.phtml qui compose notre Layout. Au final, il devrait ressembler juste à ceci : /application/layout/header.phtml

<div id="header">Tutoriel ZF</div>
<div id="liensheader">
    <a href="<?php echo $this->BaseUrl(); ?>"><span>Accueil</span></a>
    <?php 
        $auth = $this->getAuth('admin');
        if($auth)
        {
    ?>
    <a href="<?php echo $this->url(array('module' => 'admin' ,'controller' => 'index', 'action' => 'logout'), "", true); ?>">
        <span>Déconnexion</span>
    </a>

    <?php 
        }else{
    ?>
    <a href="<?php echo $this->url(array('module' => 'admin' ,'controller' => 'index', 'action' => 'index'), "", true); ?>">
        <span>Identifiez-vous</span>
    </a>
    <?php  } ?>
</div> 
Attention, ici je fais les tests avec une aide de vue personnalisée. Je vais comme ça vous apprendre à rajouter une nouvelle Library en plus de Zend. La Library s’appellera App. Elle s’agrandira au fur et à mesure de l’avancé des tutoriels.

Tout d’abord, allez modifier le bootstrap en ajoutant la fonction suivante : /application/Bootstrap.php

protected static function _initNamespaces() 
{
    $autoloader = Zend_Loader_Autoloader::getInstance();
    $autoloader->registerNamespace('App_');
}

Ensuite, pour que Zend_View trouve nos différentes aides de vue automatiquement, nous allons rajouter la ligne suivante dans _initView() :

$view->addHelperPath('App/View/Helper/', 'App_View_Helper');

Voilà. Maintenant que notre Library App existe, voici la première classe présente : /library/App/View/Helper/GetAuth.php :

class App_View_Helper_GetAuth
{
    function getAuth($namespace=null)
    {
        $auth = Zend_Auth::getInstance()->setStorage(new Zend_Auth_Storage_Session($namespace));
        return $auth->getInstance()->getIdentity();
    }
}

Cette classe va nous retourner les informations e la personne authentifiée.

Comme indiquée dans le précédent article, à la fin Zend_Auth va stocker, dans une variable de session, toutes les informations du membre mis à par son mot de passe. Comme ceci, nous testons si la variable est vide ou pas. Si elle est vide, l’utilisateur n’est pas connecté, sinon, il est bien présent.

Vu que nous demandons de stocker les informations dans le Namespace de session admin, nous le renseignons dans les paramètres de getAuth().

Voilà, j’espère que ce complément vous a été utile.

Initiation à PHING

Initiation à PHING

by Throrïn 1 Comment

Aujourd’hui, nous allons voir comment fonctionne PHING. Je vais donc vous montrer comment réaliser un script simple affichant un message sur notre terminal, puis copiant certains fichiers dans un autre dossier.

Pour les articles traitants de PHING, j’utilise le système Ubuntu. Vous devrez donc convertir certaines commandes en fonction de votre système.

Avant tout, il vous faut installer PHING. PHING est installable via PEAR. Vous devez donc, installer la Library PHP-PEAR. Pour ce faire, dans un terminal vous devrez juste taper :

sudo apt-get install php-pear

Ensuite, quand pear est installé, vous devrez taper les commandes suivantes pour pouvoir installer PHING :

sudo pear channel-discover pear.phing.info
sudo pear install phing/phing

Pour mettre à jour PHING vous aurez juste à taper

sudo pear update phing/phing

Pour vérifier l’installation de PHING, tapez juste ceci dans votre console : phing Et voici le retour : Buildfile: build.xml does not exist!.

Bien, maintenant que PHING est correctement installé, nous allons nous attaquer à notre projet.

Pour ce faire nous aurons besoin du fichier index.php contenant juste les lignes suivantes : Nous placerons ce fichier dans un dossier vide du nom de phing. Dans ce dossier nous allons aussi créer notre fichier build.xml contenant tout notre programme phing.

Le but de ce petit programme sera d’afficher un message et de copier ce fichier dans un nouveau dossier dans /var/www. Ce nouveau dossier aura le nom d’un projet saisit dans notre application.

Voici le script de notre application :

<?xml version="1.0" encoding="UTF-8"?>
<project name="TutoPHING" default="build">
    <propertyprompt propertyName="projet" defaultValue="projet"
        promptText="Entrez le nom de votre projet : " />
    <target name="build">
        <echo>Création du projet ${projet}</echo>
        <mkdir dir="/var/www/${projet}" />
        <echo>Copie du fichier index.php</echo>
        <copy file="index.php" tofile="/var/www/${projet}/index.php" 
              overwrite="true"/>
        <echo>Le programme est terminé</echo>
    </target>
</project>

Un projet est toujours contenu dans la balise <project>. Dedans on renseigne le nom de notre application ainsi que le target par défaut.

Si vous renseignez un target par défaut inexistant, PHING vous retournera une erreur.

Ensuite, vous l’aurez compris, la balise <target> correspond un peu à une fonction. Nous lui définissons un nom et nous pouvons aussi dire quels sont les targets nécessaires à son exécution.

Voilà ce qu’il y a à savoir sur l’architecture d’une application PHING. Pour plus de renseignements, je vous conseille d’aller voir là : documentation. Sinon posez vos questions.

Si nous lançons le programme, voici ce que ça nous retourne :

C’était qu’un bref aperçu de PHING, vous pouvez vous en servir pour contrôler les normes de codage de vos projets, générer simplement un nouveau projet à la manière de Zend Too, ou, tout simplement, la génération de Template PHP pour vos différentes classes.

J’espère que ce bref aperçu vous aura fait apprécier PHING.