13 septembre 2013

Scrum et Trello, le sprint backlog

Trello est un formidable outil de gestion de listes. A première vue, son interface rappelle un Scrum Board. Pour cette raison, il est tentant de vouloir l'utiliser comme Board virtuel. Il y a quelques mois, je me suis également laissé tenter, j'ai donc cherché une manière d'utiliser Trello pour faire du Scrum. Voici le résulat de cette recherche.

L'outil

Pour mimer un Scrum Board avec Trello, il existe plusieurs conventions et outils.
On peut utiliser Scrum for Trello. Cette extension pour Google Chrome permet de "mesurer" et/ou "évaluer" les cartes et les colonnes. Cela peut suffire, mais il reste à choisir ce que l'on va mettre dans chaque colonne

Choisir les colonnes

De manière classique, on peut créer les listes suivantes :
  • Todo
  • Work In Progress
  • Done
  • Parking
  • Test
  • Urgence
  • ...
Ce découpage en colonne est directement inspiré du Scrum Board, mais cette méthode a quelques inconvénients :
  • Il est difficile de matérialiser les User Story, 
  • Elle impose de faire un Board par Sprint, voir à archiver toutes les cartes à la fin de chaque sprint

Une colonne par User Story

A mon sens, il est plus important de matérialiser les User Story que l'état dans lequel se trouve une Task. L'idée est donc de faire une liste par User Story. Cette méthode a plusieurs avantages :
  • Un Board n'est pas limité à un Sprint
  • Une fois terminée la User Story peut être archivée entièrement avec toutes ses Tasks
  • Les Tasks restent toujours dans la même colonne, elles sont plus faciles à retrouver

Un label, pour chaque état

Avec la méthode précédente, on perd la notion d'état (Todo, Wok, Done). Pour éviter cela, il suffit d'utiliser les Labels proposés par Trello. Grâce aux filtres, on pourra facilement visualiser le travail en cours, le travail à faire et le travail terminé.

Les critères d'acceptation

Avec une colonne par User Story, on peut ajouter une ou plusieurs cartes particulières pour afficher les critères d'acceptation. Soit autant de cartes qu'il y a de critères, soit une seul carte contenant une Check List avec l'ensemble des critères.
 
Pour différencier cette ou ces cartes, on utilisera également un Label. On pourra aussi utiliser le champ Description de la carte pour détailler et expliquer la User Story

Démonstration

Voici un Board  pour voir ce que cela peut donner :

https://trello.com/b/wlmsArbP/template-sprint-backlog

Copie d'écran

23 février 2012

node-xml-mapping = xml2json.js & json2xml.js

xml-mapping est un module NodeJS qui permet de transformer des données XML en une structure de données Javascript (JSON). Ce module permet également de réaliser l'opération inverse en transformant une structure de données Javascript en XML. Ce module se caractérise par quelques avantages :

  • 100% Javascript
  • Bidirectionnel
  • Prise en charge des Comments, des CDATA, des Processing Instructions

Convention

Pour transformer du XML en JSON il faut des règles de correspondance. Ce module reprend celles utilisées par Google dans son protocole GData (cf. http://code.google.com/apis/gdata/docs/json.html ). L'approche des ingénieurs Google est intéressante car elle cherche à adapter la structure des données aux caractéristiques de Javascript. Par exemple, les attributs ne sont pas dans un tableau d'attributs ou bien la valeur d'un balise est stockée dans un champ spécial ou encore les sous balises sont regroupées dans une collection et les balises multi-occurrentes sont regroupées dans un tableau.

Démonstration

Ce démonstrateur :

var xm = require('../lib/xml-mapping.js')
 ,util = require('util')
 ,assert = require('assert');

[
 '<key>value</key>'
 ,'<key attr="value1">value2</key>'
 ,'<key><key1>value1</key1><key2>value2</key2></key>'
 ,'<key><key>value1</key><key>value2</key></key>'
 ,'<key><key><key>value2</key></key></key>'
 ,'<key><![CDATA[value]]></key>'
 ,'<key><!--value--></key>'
].forEach(function(xml) {
  var json = xm.tojson(xml);
  process.stdout.write(xml);
  process.stdout.write('\n');
  process.stdout.write(util.inspect(json, false, null, true));
  process.stdout.write('\n\n');
  assert.equal(xml, xm.toxml(json));
})

affichera :

<key>value</key>
{ key: { '$t': 'value' } }

<key attr="value1">value2</key>
{ key: { attr: 'value1', '$t': 'value2' } }

<key><key1>value1</key1><key2>value2</key2></key>
{ key: 
   { key1: { '$t': 'value1' },
     key2: { '$t': 'value2' } } }

<key><key>value1</key><key>value2</key></key>
{ key: 
   { key: 
      [ { '$t': 'value1' },
        { '$t': 'value2' } ] } }

<key><key><key>value2</key></key></key>
{ key: { key: { key: { '$t': 'value2' } } } }

<key><![CDATA[value]]></key>
{ key: { '$cd': 'value' } }

<key><!--value--></key>
{ key: { '$c': 'value' } }


Installation et code source

Le code source est disponible sur GitHub : http://github.com/lindory-project/node-xml-mapping

et on peut directement l'installer avec NPM :

% npm install xml-mapping

16 novembre 2011

Lecture ligne par ligne avec NodeJS

Lire un fichier ou plus généralement un flux de données ligne par ligne est une opération triviale pour toutes les personnes connaissant la fonction fgets. Voici 4 méthodes pour résoudre cette problématique basique avec NodeJS :


0. String & Split

C'est la méthode la plus simple, il suffit de charger la totalité du fichier dans une chaîne de caractères puis découper cette chaîne en fonction du caractère \n

#!/usr/bin/env node

var buffer = '';

process.stdin.resume();
process.stdin.setEncoding('utf8');

process.stdin.on('data', function (chunk) {
  buffer += chunk;
});

process.stdin.on('end', function () {
  buffer.split('\n').forEach(function(line) {
    process.stdout.write(line);
    process.stdout.write('\n');
  });
});

1. Module byline


#!/usr/bin/env node

var byline = require('byline');

process.stdin.resume();
process.stdin.setEncoding('utf8');

stream = byline.createLineStream(process.stdin);

stream.on('data', function(line) {
  process.stdout.write(line);
  process.stdout.write('\n');
});
stream.on('end', function() {
  // Ended !
});

2. Module carrier


#!/usr/bin/env node

var carrier = require('carrier');

process.stdin.resume();
process.stdin.setEncoding('utf8');

carrier.carry(process.stdin, function(line) {
  process.stdout.write(line);
  process.stdout.write('\n');
});


3. Module line-reader


#!/usr/bin/env node

var lineReader = require('line-reader');

lineReader.eachLine('/dev/stdin', function(line, last) {
  process.stdout.write(line);
  process.stdout.write('\n');
});

4. Module node-each-line


#!/usr/bin/env node

var each_line = require('./each_line').each_line;

each_line(process.stdin, function (line) {
  process.stdout.write(line);
});


Comparaison

Pour faire son choix, il est intéressant de comparer leur performance pour cela
on commence par les installer:

npm install byline
npm install carrier
npm install line-reader
wget https://raw.github.com/aaronj1335/node-each-line/master/each_line.js

Ensuite, on utilise un fichier qui va générer quelques milliers de lignes :

#!/usr/bin/env node

for(var i = 1; i <= 100000; i++) {
 process.stdout.write(i+'');
 process.stdout.write('\n');
}

Reste à exécuter le tout :

$ time ./input.js | ./00.js >/dev/null

real 0m14.753s
user 0m14.973s
sys 0m1.288s

$ time ./input.js | ./01.js >/dev/null

real 0m11.714s
user 0m11.885s
sys 0m1.204s

$ time ./input.js | ./02.js >/dev/null

real 0m11.495s
user 0m11.761s
sys 0m1.164s

$ time ./input.js | ./03.js >/dev/null

node.js:134
        throw e; // process.nextTick error, or 'error' event on first tick
        ^
Error: Socket is not writable
    at Socket._writeOut (net.js:391:11)
    at Socket.write (net.js:377:17)
    at Object.<anonymous> (/home/thouveni/Tests/node/lines/input.js:4:17)
    at Module._compile (module.js:402:26)
    at Object..js (module.js:408:10)
    at Module.load (module.js:334:31)
    at Function._load (module.js:293:12)
    at Array.<anonymous> (module.js:421:10)
    at EventEmitter._tickCallback (node.js:126:26)

real 0m0.057s
user 0m0.068s
sys 0m0.036s

$ time ./input.js | ./04.js >/dev/null

real 0m5.096s
user 0m5.764s
sys 0m0.624s

Conclusion

Le module line-reader ne fonctionne pas, à ignorer. Les modules carrier et byline sont équivalents. Et le script node-each-line est le plus rapide mais il ne permet pas d'intercepter la fin de fichier. Le choix est donc une affaire de gout. Personnellement, j'utilise byline.

08 septembre 2011

Underscore + JSONSelect = XPath for JSON ?

XML est largement utilisé pour formater, stocker, échanger des informations structurées. Et malgré l’étendu de ses capacités, il n'en reste pas moins qu'un support. Et en tant que support JSON n'a rien à envier à XML. N'importe quelle information peut-être stocker avec JSON. Par contre l'écosystème XML est riche et on peut facilement transformer, valider, émietter nos données, ce qui semble moins évident avec JSON. Mais qui dit JSON dit Javascript et l'écosystème Javascript est également très riche et il permet de faire aussi bien voir mieux que XML dans certain domaine. Voici une technique pour picorer de l'information comme on le ferai avec XPath sur du XML mais sur un objet JSON.

JSONSelect

JSONSelect permet de picorer dans un objet javascript à l'aide de sélecteur CSS. Exemple :
#!/usr/bin/env node

var jsel = require('JSONSelect');
var doc = {
	"id": "0001",
	"type": "donut",
	"name": "Cake",
	"ppu": 0.55,
	"batters":
		{
			"batter":
				[
					{ "id": "1000", "type": "None" },
					{ "id": "1001", "type": "Regular" },
					{ "id": "1002", "type": "Chocolate" },
					{ "id": "1003", "type": "Blueberry" },
					{ "id": "1004", "type": "Devil's Food" }
				]
		},
	"topping":
		[
			{ "id": "5001", "type": "None" },
			{ "id": "5002", "type": "Glazed" },
			{ "id": "5005", "type": "Sugar" },
			{ "id": "5007", "type": "Powdered Sugar" },
			{ "id": "5006", "type": "Chocolate with Sprinkles" },
			{ "id": "5003", "type": "Chocolate" },
			{ "id": "5004", "type": "Maple" }
		]
};

console.log(jsel.match('.name', doc));
// [ 'Cake' ]
console.log(jsel.match('number', doc));
// [ 0.55 ]
console.log(jsel.match('.batter .type', doc));
// [ 'Regular', 'Chocolate', 'Blueberry', 'Devil\'s Food' ]
console.log(jsel.match('.type ~ .id:val("5005")', doc));
// [ '5005' ]
console.log(jsel.match('.type:val("None") ~ .id', doc));
// [ '1000', '5001' ]



Underscore

Underscore fournit ~ 60 fonctions orientées programmation fonctionnelle.
Et partie elles, une trentaine simplifient grandement la manipulation et le traitement des listes et des tableaux. Exemple :
#!/usr/bin/env node

var _ = require('underscore');

var arr = ["1000", "1001", "1002", "1003", "1004"];
console.log(_.first(arr));
// [ '1000' ]
console.log(_.without(arr, "1000"));
// [ '1001', '1002', '1003', '1004' ]
console.log(_(arr).chain().without(arr, "1000").first().value());
// 1001
console.log(_.map(arr, function(value) {
			return '#'+value ;
}));
// [ '#1000', '#1001', '#1002', '#1003', '#1004' ]
console.log(_(arr).chain().map(function(value) { 
			return value.substr(1, 2);
	}).uniq().first().value());
// 00


JSONSelect & Underscore

JSONSelect permet de récupérer des listes d'objet ou des tableaux de valeur, Underscore permet de manipuler des listes et des tableaux.
Coupler les deux offre donc un outil extrêmement puissant pour aller piocher et trier de l'information. Exemple :
#!/usr/bin/env node

var jsel = require('JSONSelect'),
	_ = require('underscore');

//  Underscore + JSONSelect
_.mixin({
		jsel : function(doc, sel) {
			return jsel.match(sel, doc)
		}
});

var data = [
	{ name:'Africa', type:'continent'},
	{ name:'Egypt', type:'country' },
	{ name:'Kenya', type:'country'},
	{ name:'Nairobi', type:'city' },
	{ name:'Mombasa', type:'city' },
	{ name:'Sudan', type:'country'},
	{ name:'Khartoum', type:'city' },
	{ name:'Asia', type:'continent'},
	{ name:'China', type:'country' },
	{ name:'India', type:'country' },
	{ name:'Russia', type:'country' },
	{ name:'Mongolia', type:'country' },
	{ name:'Australia', type:'continent'},
	{ name:'Commonwealth of Australia', type:'country'},
	{ name:'Europe', type:'continent'},
	{ name:'Germany', type:'country' },
	{ name:'France', type:'country' },
	{ name:'Spain', type:'country' },
	{ name:'Italy', type:'country' },
	{ name:'North America', type:'continent'},
	{ name:'Mexico', type:'country'},
	{ name:'Mexico City', type:'city'},
	{ name:'Guadalajara', type:'city'},
	{ name:'Canada', type:'country'},
	{ name:'Ottawa', type:'city'},
	{ name:'Toronto', type:'city'},
	{ name:'United States of America', type:'country' },
	{ name:'South America', type:'continent'},
	{ name:'Brazil', type:'country'},
	{ name:'Argentina', type:'country'}
];

console.log(_(data).chain().jsel('.type').uniq().value());
// [ 'continent', 'country', 'city' ]
console.log(_(data).chain().jsel('.type:val("city") ~ .name').sortBy(function(value) { 
			return value.charCodeAt(0)
	}).value());
// [ 'Guadalajara', 'Khartoum', 'Mombasa', 'Mexico City', 'Nairobi', 'Ottawa', 'Toronto' ]


06 septembre 2011

Installer NodeJS dans son HOMEDIR avec STOW

Il y a quelque temps déjà, j'avais présenté l'utilitaire stow. Mais avec les distributions Linux récentes cet utilitaire avait peu d’intérêt tant l'usage d'apt-get install suffisait la majorité du temps. Mais voilà, avec NodeJS, on ne peut pas attendre que la dernière version soit packagée pour l'utiliser. Il faut donc l'installer soit même, et si il existe plusieurs méthodes, aucune ne permet de changer de version de nodejs en un fragment de seconde. Démonstration !

STOW

Stow permet de recréer une arborescence système à l'aide de liens symboliques. Ces liens pointent sur un répertoire isolé et ils sont générés automatiquement à l'aide d'une simple commande.


Pré requis système

Pour installer et compiler NodeJS, il faut vérifier que les paquets g++ et libssl-dev sont installés.

#!/bin/sh

sudo apt-get install g++ libssl-dev


Installation de STOW

#!/bin/sh

# CHOOSE THE VERSION YOU WANT 
export STOW_VERSION=1.3.3

mkdir ~/local/stow
mkdir -p ~/local/src
mkdir ~/local/bin
mkdir ~/local/info
mkdir ~/local/etc
mkdir ~/local/include
mkdir ~/local/share
mkdir ~/local/share/man
mkdir ~/local/lib
mkdir ~/local/man
mkdir ~/local/man/man1
mkdir ~/local/man/man2
mkdir ~/local/man/man3
mkdir ~/local/man/man4
mkdir ~/local/man/man5
mkdir ~/local/man/man6
mkdir ~/local/man/man7
mkdir ~/local/man/man8

cd ~/local/src
curl http://ftp.gnu.org/gnu/stow/stow-${STOW_VERSION}.tar.gz | tar -xzf -

cd stow-${STOW_VERSION}
./configure --prefix=~/local/stow/stow-${STOW_VERSION}

make
make install

cd ~/local/stow/
./stow-1.3.3/bin/stow stow-1.3.3

echo "export PATH=\$HOME/local/bin:\${PATH:=}" >> ~/.profile
echo "export MANPATH=\$HOME/local/man:\${MANPATH:=}" >> ~/.profile
echo "export LD_LIBRARY_PATH=\$HOME/local/lib:\${LD_LIBRARY_PATH:=}" >> ~/.profile

export PATH=$HOME/local/bin:${PATH:=}
export MANPATH=$HOME/local/man:${MANPATH:=}
export LD_LIBRARY_PATH=$HOME/local/lib:${LD_LIBRARY_PATH:=}


NodeJS

NodeJS doit être compilé manuellement pour bénéficier des dernières versions. On va donc compiler et installer chaque version dans un répertoire spécifique.


Installation de NodeJS pour STOW

#!/bin/sh

# CHOOSE THE VERSION YOU WANT 
export NODEJS_VERSION=0.6.1

mkdir -p ~/local/lib/node_modules
cd ~/local/src

curl http://nodejs.org/dist/v${NODEJS_VERSION}/node-v${NODEJS_VERSION}.tar.gz | tar -xzf -
cd ~/local/src/node-v${NODEJS_VERSION}

./configure --prefix=~/local/stow/node-${NODEJS_VERSION}
make
make install

# Careful, check if stow is installed
cd ~/local/stow
stow node-${NODEJS_VERSION}

echo "export NODE_PATH=\$HOME/local:\$HOME/local/lib/node_modules" >> ~/.profile
export NODE_PATH=$HOME/local:$HOME/local/lib/node_modules


Changer de version facilement

Maintenant tester une nouveau version de NodeJS est très simple :

$ node -v
v0.4.11
$ cd ~/local/stow
$ stow -D node-0.4.11
$ stow node-0.6.1
$ node -v
v0.6.1

26 août 2011

HTTP request loop in NodeJS

Comment envoyer 200000 requêtes HTTP avec NodeJS ? A priori cette question semble facile ? Voyons si c'est le cas ?

Commençons petit

Avant d'envoyer plusieurs centaines de requêtes voyons déjà comment en envoyer une seule :

#!/usr/bin/env node

var http = require('http');

var options = {
  host: '127.0.0.1',
  port: 80,
  path: '/'
};

http.get(options, function(response) {
    console.log(response.statusCode);
});

On boucle !

#!/usr/bin/env node

var http = require('http');

var options = {
  host: '127.0.0.1',
  port: 80,
  path: '/'
};

for(var i = 0; i < 2000000; i++) {
	http.get(options, function(res) {
   	    console.log(res.statusCode);
	});
}

Résultat :


FATAL ERROR: JS Allocation failed - process out of memory

Économiser la mémoire

Ok, on y a été un peu fort, on va optimiser notre boucle en sortant le client HTTP de la boucle, histoire de l'instancier qu'une seule fois.

#!/usr/bin/env node

var http = require('http');


var client = http.createClient(80, '127.0.0.1');


for(var i = 0; i < 200000; i++) {
	var request = client.request("GET", '/')
	request.end();
	request.on('response', function(response) {
			console.log(response.statusCode);
	});
}

Résultat :


node.js:205
        throw e; // process.nextTick error, or 'error' event on first tick
              ^
Error: EMFILE, Too many open files
    at net_legacy.js:741:19
    at Object.lookup (dns_legacy.js:159:5)
    at Socket.connect (net_legacy.js:729:20)
    at Object.createConnection (net_legacy.js:268:5)
    at new ClientRequest (http2.js:1041:23)
    at Client.request (http2.js:1475:11)
    at Object.<anonymous> (/home/touv/tests/node/loop02.js:11:23)
    at Module._compile (module.js:416:26)
    at Object..js (module.js:434:10)
    at Module.load (module.js:335:31)

Oups, NodeJS est-il incapable d'exécuter un traitement aussi simple ? Ou mon code est-il mauvais ?

Pool HTTP Request

Pour lancer nos 200000 requetes, il va falloir économiser la mémoire et les descripteurs, mais surtout s'adapter au mode asynchrone et éviter de vouloir balancer 200000 requêtes en parallèle !

Pour nous aider, il existe le module node-pool qui propose :
"a small but usefull resource pooling/limiting/throttling library".
Voilà donc la solution à notre question toute simple ...

#!/usr/bin/env node

var http = require('http');

var pool = require('generic-pool').Pool({
		name     : 'http_request',
		create   : function(callback) {
			var c = http.createClient(80, '127.0.0.1');
			callback(null, c);
		},
		destroy  : function(client) { },
		max      : 10,
		idleTimeoutMillis : 300,
		log : false
});


for(var i = 0; i < 200000; i++) {
	pool.acquire(function(err, client) {
			var request = client.request("GET", '/');
			request.end();
			request.on('response', function(response) {
					console.log(response.statusCode);
					pool.release(client);
			});
	});

}

19 août 2011

Mapping XML - Array - JSON en PHP

Vouloir établir une correspondance entre JSON et XML n'est pas nouveau. (cf. Converting Between XML and JSON). D'ailleurs, le Zend Framework propose sa solution XML to JSON conversion.
Cependant,

  • le format est-il adapté ?
  • l’opération inverse est-elle possible ?

Vouloir passer du XML au JSON revient en fait à transformer du XML en une structure mémoire de type tableau. Toutes les solutions en PHP que j'ai trouvé passe par cette étape. Aucune ne transforme la chaîne de caractères XML en chaîne de caractères JSON. La véritable question est donc :
Comment faire un mapping entre XML et un tableau PHP ?
Le format JSON n'étant plus qu'une sérialisation du tableau. Du coup, l'opération inverse n'est pas de vouloir transformer du JSON en XML mais bien de vouloir transformer un tableau en XML. Le problème est donc de passer d'une structure mémoire à un fichier XML et réciproquement. CQFD ;-)
La belle affaire me direz-vous ? C'est pareil ! Oui sauf qu'en abordant le problème de cette manière, on doit produire un code capable de transformer toute structure mémoire en XML, et cela a une influence directe sur le format d’équivalence que l'on va choisir. Et à ce petit jeu là, c'est le format proposé par Google qui me semble le plus adapté ! cf. Using JSON in the Google Data Protocol

XML_Array

Voici donc une petite classe PHP, disponible au travers d'un package PEAR qui permet de transformer n'importe quel document XML en tableau PHP. Mais qui permet également l'opération inverse à savoir transformer n'importe quel tableau PHP en fichier XML.

array2xml.php

<?php
require_once 'XML/Array.php';

$array_input = array (
  'rdf:RDF' => 
  array (
    'xmlns:rdf' => 'http://www.w3.org/1999/02/22-rdf-syntax-ns#',
    'xmlns' => 'http://www.exemple.com/fake#',
    'rdf:Description' => 
    array (
      0 => 
      array (
        'rdf:about' => 'urn:id:aaa',
        'name' => 
        array (
          '#text' => 'Dupont T.',
        ),
        'email' => 
        array (
          'type' => 'main',
          '#text' => 'dupont@example.com',
        ),
      ),
      1 => 
      array (
        'rdf:about' => 'urn:id:bbb',
        'name' => 
        array (
          '#text' => 'Dupond D.',
        ),
        'email' => 
        array (
          'type' => 'main',
          '#text' => 'dupond@exeample.com ',
        ),
      ),
    ),
  ),
);

$xml = XML_array::export($array_input);
$array_output = XML_array::import($xml);

assert($array_input == $array_output);

?>

xml2array.php

<?php
require_once 'XML/Array.php';
$xml_input = <<<EOT
<rdf:RDF
	xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
	xmlns="http://www.exemple.com/fake#">
	<rdf:Description rdf:about="urn:id:aaa">
		<name>Dupont T.</name>
		<email type="main">dupont@example.com</email>
	</rdf:Description>
	<rdf:Description rdf:about="urn:id:bbb">
		<name>Dupond D.</name>
		<email type="main">dupond@exeample.com </email>
	</rdf:Description>
</rdf:RDF>
EOT;

$array = XML_Array::import($xml_input);
$xml_output = XML_array::export($array);
 
$xml_input = preg_replace(',\s+,', '', $xml_input);
$xml_output = preg_replace(',\s+,', '', $xml_output);

assert($xml_input == $xml_output);
?>

Tables de correspondance

Règles principales
ARRAY XML
key ⇒ array( key1 ⇒ value, ) <key key1="value/>
key ⇒ array( #text ⇒ value1, ) <key>value1</key>
key ⇒ array( array(…), array(…), ) <key>…</key><key>…</key>
0 ⇒ value <![CDATA[value]]>
key ⇒ value <row key="value" />
#comment ⇒ value <!--value-→
Clefs réservées
XML values key
Text node $t, _t, _text, #text
comment node $c, _c, _comment, #comment
xml:lang xmllang, xml:lang, xml$lang
xml:space xmlspace, xml:space, xml$space
xml:id xmlid, xml:id, xml$id
xml:idref xmlidref, xml:idref, xml$idref

Benchmark

Voici une petite comparaison de performance en chargeant en mémoire séquentiellement 196867 documents XML pour un volume total de 250 Mo.


xml2str   => 53,292876 Seconds 
--------------------------------
xml2array => 178,356342 Seconds 
--------------------------------
xml2dom   => 64,135433 Seconds 

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/xml_array

ou on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/xml_array

Webographie

10 juillet 2011

PHP Universal Fetchor

Après avoir présenté des classes PHP comme PQO, CMD et PSO, voici un billet qui tente de les mettre en perspective à l'aide d'une question. Quel est le point commun entre :

  • exécuter une requête SQL
  • exécuter une commande système
  • découper une chaîne de caractères en petits bouts
  • lire le contenu d'un fichier ?

Avez-vous trouvé ? Et bien, si toutes ces opérations sont différentes, l'obtention du résultat de chaque traitement peut être obtenu suivant une interface unique :

interface Fetchor
{
    public function map($f);
    public function fetch();
    public function fetchAll();
    public function close();
}

Démonstration


$s = PSO::factory('Hello,How,Are,You,Today')->setEnding(',');
$s->map(function($e) {
   echo $e, PHP_EOL;
});

$s = PQO::factory('SELECT title, description FROM posts')->fire();
$s->map(function($e) {
   echo $e->title, PHP_EOL;
});

$s = CMD::factory('/bin/ls')->param('/tmp')->fire();
$s->map(function($e) {
   echo $e, PHP_EOL;
});

$s = PIO::factory('/etc/passwd');
$s->map(function($e) {
   echo $e, PHP_EOL;
});

Maintenant, si votre PHP ne supporte pas les fonctions anonymes, aucun problème :


while($e = $s->fetch()) {
   echo $e, PHP_EOL;
});

Rien de neuf

Bien sur uniformiser le parcours d'un jeu de résultat n'est pas une idée neuve. PHP propose notamment StreamWrapper qui propose comme méthode pivot la lecture de fichier façon C : fopen, fread, fclose. A chacun son style ...

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/plor

ou on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/plor

08 juillet 2011

Je RESPEAR en PHP

PEAR permet de regrouper dans un même paquet du code PHP.
PIRUM permet de mettre facilement à disposition des paquets PEAR.
Mais, comment passer de l'un à l'autre rapidement et automatiquement ?
Avec RESPEAR bien sur !

Interface REST

RESPEAR est une interface REST à Pirum. On va pouvoir ajouter (ou supprimer) des paquets PEAR à un serveur PIRUM à distance, simplement à l'aide d'une requête HTTP, exemple :


cat ExAppli-1.0.1.tgz | curl \
      -u respear:354f123b-7a75-f654-9153-0e15dc2f5b52 \
      -X POST --data-binary @- \
      http://demo.respear.net/respear/

Construction automatique

RESPEAR va encore plus loin, il peut même construire pour vous un paquet PEAR uniquement à partir d'un fichier package.xml contenu dans votre gestionnaire de source, exemple :


curl -u respear:354f123b-7a75-f654-9153-0e15dc2f5b52 \
     -X POST \
     -H "X-URL: https://github.com/touv/plor/raw/master/package.xml" \
     http://demo.respear.net/respear/

Suivre les versions

Accessoirement, RESPEAR propose un flux ATOM pour chaque paquet ajouté. On peut ainsi suivre l'arrivée de nouvelles versions, exemple : http://pear.respear.net/respear/plor/.

Migration

Du coup, j'ai automatisé la création de package pour l'ensemble des paquets PEAR de ma petite collection et en une seule commande :

  • je tague mon code source,
  • je construis un paquet PEAR
  • et je le mets à disposition sur un channel.

Cool ! Je respire ...

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/kerphi/ResPear

Et pour l'installer, le mieux est de suivre la procédure.

17 mai 2011

CMD, une facade PHP pour les commandes système

Dans la lignée de mes précédents billets, voici une nouvelle classe de type Facade. Cette fois-ci, l'idée est de pouvoir lancer des commandes système autrement qu'avec les fonctions system, shell_exec, popen, etc. Car pour les rares habitués de ce blog, vous aurez remarqué que ma lubie du moment est de chercher à voir de quelle manière on peut écrire le moins de code PHP, tout en gardant un code lisible.

Démonstration


       // Afficher le résultat
       echo CMD::factory('/bin/ls')
            ->option('all')
            ->option('b')
            ->option('color', 'never')
            ->option('format', 'single-column')
            ->option('t')
            ->option('reverse')
            ->param('/usr')
            ->fire()
            ->fetchAll()
            ->toString();

       // Envoyer le résultat dans un fichier
       CMD::factory('/bin/ls')
            ->option('all')
            ->param('/usr')
            ->bind(1, '/tmp/t.txt')            
            ->fire();


       // On lit le résultat en "streaming"
       $c = CMD::factory('/usr/bin/curl', array('long_option_operator' => ' '))
           ->option('no-buffer')
           ->option('request', 'GET')
           ->param('http://www.google.com')
           ->fire();

       while($buf = $c->fetch()) {
           echo $buf;
       }

       // On lance une commande en parallèle de l'exécution du script courant
       $c = CMD::factory('/bin/sleep')
            ->param('1')
            ->fire();
       echo 'On attend';

       while($c->isAlive()) {
            usleep(500000);
            echo '.';
       }
       echo 'Fini !';

Vous remarquerez que l'interface est quasiment identique à la classe PQO. Parcourir le résultat d'une commande ou d'une requête SQL se traduit par un code simple et similaire.

PSOStream

Lancer une commande, c'est bien mais pouvoir lui envoyer et recevoir des données, c'est mieux. Et dans ce cas précis, la classe PSOStream a tout son sens. Celle-ci va permettre de lier entrée et sortie standard avec une chaîne de caractère PHP. Le paradigme POO imposerait du polymorphisme or ici, on impose une chaîne de caractères contenant une URL


// Envoie d'une chaîne de caractères sur l'entrée standard
$in = new PSO('Lorem ipsum dolor sit amet, consectetur adipiscing elit. Fusce lacinia placerat tortor auctor ultricies.');
$out = new PSO;
CMD::factory('/usr/bin/fmt')
    ->option('width', '40')
    ->bind(0, $in->toURL())
    ->bind(1, $out->toURL())
    ->fire();

echo $out;

// Récupération de la sortie standard
$out = new PSO;

CMD::factory('/bin/ls')
    ->option('all')
    ->option('b')
    ->option('color', 'never')
    ->option('format', 'single-column')
    ->option('t')
    ->option('reverse')
    ->param('/usr')
    ->bind(1, $out->toURL())
    ->fire();

echo $out;

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/plor

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/plor

05 mai 2011

PSOStream, string et stream enfin réuni

Il y a bien longtemps déjà, à l'époque où j'ai écrit Pxxo, j'avais cherché à manipuler des buffers qui pouvait être indifféremment en mémoire ou sur disque. Pxxo intègre donc des classes qui implémentent plus ou moins bien cette idée. Jusqu'à récemment, je n'avais plus jamais eu besoin d'un tel mécanisme. Mais voilà qu'au détour d'un besoin fonctionnel, celle-ci réapparaît ...

Cette fois-ci, pas question de développer une myriade de classe. Dans la logique de mes derniers développements, j'ai cherché à interfacer simplement ce que sait faire PHP nativement.

PSOStream

Le principe est de coupler l'usage de la classe PSO et des streams PHP afin de pouvoir utiliser une variable comme on le ferait avec un fichier


        $h = fopen('pso://t3', 'w');
        fwrite($h, 'azerty');
        fclose($h);

        $h = fopen('pso://t3', 'r');
        for($c = ''; !feof($h); $c .= fread($h, 10));
        fclose($h);

        echo $c; // azerty

Rien de neuf ?

Tous les gourous PHP auront reconnu une implémentation légèrement améliorée d'un exemple enfuit dans la documentation. Mais ce qui m'intéresse est ailleurs, c'est le couplage avec la classe PSO :

        // Pour lecture 
        $s = new PSO('azerty');
        $h = fopen($s->toURL(), 'r');
        for($c = ''; !feof($h); $c .= fread($h, 10));
        fclose($h);
        echo $c; // azerty

        // Pour écriture       
        $s = new PSO();
        $h = fopen($s->toURL(), 'w');
        fwrite($h, 'azerty');       
        fclose($h);
        echo $s; // azerty

Inutile ?

Comme ça, de but en blanc, ça n'a l'air de rien, ça semble ne servir à rien, et ça ne révolutionne pas les usages. Mais dans mon cas très précis, c'est utile et ça rend le code extrêmement lisible. Pour vous en convaincre, je vous invite à attendre mon prochain billet qui je l'espère exposera un cas d'utilisation...

17 avril 2011

PQO une facade pour PDO

Si, comme moi, vous faites partie des cancres qui n'utilisent pas une couche de persistance pour accéder à votre base de données alors ce billet a une chance de vous intéresser. La solution exposée ici, a comme unique but de me permettre de lancer des requêtes SQL encore plus simplement qu'en utilisant l'objet PHP standard PDOStatement.

Dans la lignée de mes précédents billets, mon objectif est de pouvoir chainer les commandes afin d'avoir à écrire le moins de code possible tout en restant lisible.

Démonstration


$pdo = PDO($dsn);

// Récupérer l'unique valeur d'un champ : 
$sql = 'SELECT count(*) counter FROM clients;'

echo PQO::factory($pdo, $sql)
     ->fire()
     ->fetch()
     ->counter;


// Récupérer une ligne de résultat : 
$sql = 'SELECT nom, adresse FROM clients WHERE id=? AND flag=?;'

$row = PQO::factory($pdo, $sql)
     ->bind(1, $id, PDO::PARAM_INT)
     ->bind(2, $fg, PDO::PARAM_INT)
     ->fire()
     ->fetch();
if ($row) 
     echo 'Nom : ',$row->nom,' Adresse : ', $row->adresse;

// Relancer plusieurs fois une même requête : 

$sql = 'INSERT INTO registre (id, value) VALUES (?,?);'

$qry = PQO::factory($pdo, $sql)
     ->with(1, PDO::PARAM_INT, 10)
     ->with(2, PDO::PARAM_STR, 25);

$qry->set(1, 10)->set(2, 'dix')->fire();
$qry->set(1, 100)->set(2, 'cent')->fire();
$qry->set(1, 1000)->set(2, 'mille')->fire();

// Parcourir un jeu de résultat : 
$sql = 'SELECT nom, adresse FROM clients WHERE flag=?;'

$qry = PQO::factory($pdo, $sql)
     ->bind(1, $fg, PDO::PARAM_INT)
     ->fire();
while ($row = $qry->fetch()) {
     echo 'Nom : ',$row->nom,' Adresse : ', $row->adresse, PHP_EOL;
}

// Récupérer un jeu de résultat : 
$sql = 'SELECT nom, adresse FROM clients WHERE flag=?;'

$rows = PQO::factory($pdo, $sql)
     ->bind(1, $fg, PDO::PARAM_INT)
     ->fire()
     ->fetchAll();

foreach($rows as $row) {
     echo 'Nom : ',$row->nom,' Adresse : ', $row->adresse, PHP_EOL;
}

PSO

Afin d'être au maximum "chainable", la valeur retournée est d'un objet particulier du type PSO. On peut donc automatiquement transformer ou tester la valeur retournée :


echo PQO::factory($pdo, $sql)
     ->fire()
     ->fetch()->adresse->trim()->slice(0, 3)->toInteger();

La classe possède également un singleton ce qui permet, au besoin, de réutiliser plusieurs fois la même requête sans avoir à la "repréparer":


echo PQO::singleton($pdo, $sql)
     ->fire()
     ->fetch()->name;

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/plor

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/plor

PSO, Enchainer les traitements sur une chaîne de caractères en PHP

A force d'utiliser jQuery, l'envie est grande de travailler de la même manière en PHP. Voici donc une toute petite classe qui permet d’enchaîner les traitements sur une même chaîne de caractères.

Démonstration

$s = PSO::factory("\ttoto");

echo $s, PHP_EOL;
//     toto

echo $s->trim()->md5(), PHP_EOL;
// f71dbe52628a3f83a77ab494817525c6

echo $s->slice(3,2), PHP_EOL;
// db

echo $s->isMatch('/^D.*/i') ? 'true' : 'false', PHP_EOL;
// true

echo $s->isMatch('/^D.*/') ? 'true' : 'false', PHP_EOL;
// false

echo count($s), PHP_EOL;
// 2

Non exhaustif

Le nombre de méthode applicable à cette classe est potentiellement énorme. Actuellement, leur nombre est limité et cette classe s'enrichira au grès de mes besoins ou des contributions.

Une façade à mbstring

L'intérêt de cette classe est aussi de supporter presque nativement des chaines multioctets (du moins autant que cela soit possible avec PHP).


$s = PSO::factory("éè");
echo count($s), PHP_EOL;
// 2 
echo strlen($s->toString()),PHP_EOL;
// 4

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/plor

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/plor

08 mars 2011

ATOMWriter : Création d'un flux ATOM en PHP

ATOM est un format XML conçu pour la syndication de contenu périodique. Voici une petite classe PHP sans prétention qui permet de produire rapidement un flux ATOM. L'usage de cette classe permettra d'éviter les erreurs de syntaxe XML, le flux produit est créé à l'aide la classe XMLWriter qui permet de produire du XML intègre. La classe permet de construire facilement un flux de données à l'aide de quelques méthodes.

La classe supporte également le format OpenSearch ce qui permet d'enrichir le flux avec des informations non prévues dans la norme ATOM, notamment la pagination.

Démonstration

Voici un petit bout de code qui permet de créer un flux avec deux informations.


$xmlWriter = new XMLWriter();
$xmlWriter->openUri('php://output');
$xmlWriter->setIndent(true);

$f = new ATOMWriter($xmlWriter, true);

$f->startFeed('urn:example:data')
    ->writeStartIndex(1)
    ->writeItemsPerPage(10)
    ->writeTotalResults(100)
    ->writeTitle('Index of /')
    ->writeLink('http://exemple.com/', 'text/xml');

$f->startEntry('urn:example:data-1')
    ->writeTitle('Data 1')
    ->writeLink('/1.xml', 'text/xml')
    ->writeLink('/1.txt', 'text/plain')
    ->writeContent('Une information', 'text', 'fr')
    ->writeCategory('term', '#scheme')
    ->endEntry();
$f->flush();

$f->startEntry('urn:example:data-2')
    ->writeTitle('Data 2')
    ->writeLink('2.txt', 'text/plain')
    ->writeContent('Une autre information', 'text', 'fr')
    ->endEntry();
$f->flush();

$f->endFeed();
$f->flush();

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/ATOMWriter

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/ATOMWriter

27 août 2010

REST_Client et REST_Puller à la sauce Swift

Dans mes précédents billets, j'ai présenté REST_Client et REST_Puller. Ces 2 classes PHP ont été écrites rapidement à plusieurs mois d'intervalle dans des contextes différents puis rassemblées dans un unique package PEAR. La conséquence est un manque flagrant de cohérence. Et bien c'est maintenant terminé !

Refactoring

Par la volonté et l'aide de kerphi le package REST_Client a subit une grosse refactorisation. Nous avons soigné la POO en appliquant quelques grands motifs de conception et une interface objet à la mode. Un style de programmation que l'on trouve par exemple dans la librairie Swift. Maintenant le package s'utilise très simplement avec 2 classes REST_Client et REST_EasyClient.

REST_EasyClient

Comme son nom l'indique, cette classe est simple et rapide à utiliser. Elle est idéale si l'on souhaite récupérer le résultat d'une ou plusieurs requêtes HTTP envoyées à un même serveur.

Exemples


echo REST_EasyClient::newInstance('fr.php.net')->get('/curl')->content;

// La même chose avec un Proxy
echo REST_EasyClient::newInstance('fr.php.net')
       ->setHttpProxy('proxy.exemple.com:8080')
       ->get('/curl')
       ->content;

// la même chose façon vieille école  ;-)

$client = new REST_EasyClient('fr.php.net');
$client->setHttpProxy('proxy.exemple.com:8080');
$response = $client->get('/curl');
echo $response->content;

REST_Client

Contrairement à la classe précédente, REST_Client permet de maîtriser finement la construction de la requête HTTP et la façon de l'envoyer. REST_Client permet donc d'envoyer plusieurs requêtes plus ou moins différentes de manière synchrones ou asynchrones, le tout avec une interface d'utilisation identique.

Requêtes synchrones

Permet le lancement de plusieurs requêtes séquentiellement.


$r = REST_Request::newInstance()
     ->setProtocol('http')
     ->setHost('fr.php.net')
     ->setPort(80)
     ->setMethod('GET')
     ->setUrl('/curl');

$c = REST_Client::factory('sync', array('verbose' => false));
$id = $c->fire($r);
$response = $c->fetch();

echo $response->id . PHP_EOL;
echo $response->code . PHP_EOL;
echo $response->content . PHP_EOL;

$r->setUrl('/dom');

$id = $c->fire($r);
$response = $c->fetch();

echo $response->id . PHP_EOL;
echo $response->code . PHP_EOL;
echo $response->content . PHP_EOL;

Requêtes asynchrones

Permet le lancement de plusieurs requêtes en parallèle et de manière asynchrone (Les résultats arrivent dans un ordre différent de l'ordre de lancement). Cette classe remplace feu REST_Puller.


$r = REST_Request::newInstance()
     ->setProtocol('http')
     ->setHost('fr.php.net')
     ->setHttpProxy('proxy.example.com');


$c = REST_Client::factory('sync', array(
    'verbose' => false,
    'queue_size' => 2,
));

$urls = array('/dom','/curl','/strings', '/pcre', '/xml', '/ftp', '/sockets');

foreach($urls as $i => $url) {
  $id = $c->fire($r->get($url));
  if ($i > $c->getOption('queue_size')) {
     $response = $p->fetch();
     var_dump($response);
  }
}

while($response = $p->fetch()) {
    var_dump($response);
}

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/rest_client

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/REST_Client

20 août 2010

REST_Puller, mitraillette HTTP en PHP

Dans un précédent billet, j'ai présenté le package REST_Client. Comme je l'avais laissé entendre, l'intérêt principal de ce package n'est pas de fournir une interface objet au module cURL. La fonctionnalité principale, celle que l'on trouve difficilement sur le Net, est de fournir une classe capable de lancer des centaines de milliers de requêtes HTTP : REST_Puller

Explications

Si vous connaissez le module cURL, vous savez qu'il propose une série de fonction nommé curl_multi_*. Ces fonctions permettent de lancer en parallèle plusieurs requêtes HTTP. Mais plusieurs ne veut pas dire des centaines de millier, et c'est là que la classe REST_Puller devient intéressante. Avec elle on va pouvoir charger sans interruption plusieurs milliers de requêtes dans une file d'attente qui sera vider progressivement par paquet de requêtes asynchrones. Par vider, j'entends lancement de la requête et récupération de son résultat, le tout s'effectuant en parallèle.

Démonstration

Voici un petit bout de code qui lance 50 000 requêtes avec au maximum 150 clients en parallèle.

  $p = new REST_Puller(array(
            // Pour voir le déroulement des opérations
            'debug' => true,  
   ));

   $requests = 50000; // Nombre de requêtes à tirer
   $clients  = 150;   // Nombre maximum de client à utiliser en parallèle
   $p->setOption('queue_size', $clients);

   $r = new REST_Request('localhost', 8000);

   // On charge le tireur 
   for($i = 0; $i < $requests; $i++) {

      // On tire !!!
      $id = $p->fire($r->get('/'));

      // On peut déjà récupérer les requêtes exécutées
      if ($i > $clients) 
          if (list($k, $h) = $p->fetch()) {
              echo "Request #$k ";
              echo $h->code == 200 ? 'Completed' : 'Failed';
              echo PHP_EOL;
          }
   }

   // On boucle tant que toutes les requêtes ne sont pas terminées
   while(list(, $h) = $p->fetch()) {
       echo 'Request #'.$k;
       echo $h->code == 200 ? 'Completed' : 'Failed';
       echo PHP_EOL;
   }

   // On affiche quelques statistiques
   echo $p->getInfo('requests').PHP_EOL;
   echo $p->getInfo('requests_avg').PHP_EOL;
   echo $p->getInfo('requests_sec').PHP_EOL;
   echo $p->getInfo('fetchs_hit').PHP_EOL;
   echo $p->getInfo('pulls_hit').PHP_EOL;
   echo $p->getInfo('loads_hit').PHP_EOL;
   echo $p->getInfo('time').PHP_EOL; 

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/rest_client

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/REST_Client

18 août 2010

REST_Client, pour surfer la vague

Comme le titre le laisse supposer ;-), REST_Client est un package PHP compatible PEAR qui fournit quelques classes pour interroger un serveur REST.
C'est un client HTTP, et quand on parle client HTTP en PHP, on pense directement au module cURL.
Et bien cet ensemble de classe PHP propose une interface objet orientée REST pour cURL. Cela ne constitue pas l'intérêt principal de ce package. Mais en attendant de découvrir la "killer feature" dans un prochain billet, voyons comme utiliser la classe REST_Client.

Démonstration

<?php

require_once "REST/Client.php';

$rs = new REST_Client('rest.server.com', 8080);

// GET Method
$o = $rs->get('/path/to/get')

// check network error
if ($o->isError()) die($o->error);

// check http response code
if ($o->code == 404) die('Oups, where is my page ?');

// display the content of the page
echo $o->content;

// DELETE Method
$o = $rs->delete('/path/to/delete');

// POST Method
$data = http_build_query(array('key' => 'value'));
$o = $rs->post('/path/to/post', $data)

// PUT Method
$data = '<xml>some data</xml>';
$o = $rs->put('/path/to/put', $data);

// Retrieve & print HTTP headers
echo $o->headers['x-powered-by'];
echo $o->headers['location'];

?>

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/rest_client

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/REST_Client

09 juillet 2010

Générer indifféremment du XML ou du JSON

PHP propose la classe XMLWriter qui permet de produire des données en XML. Par exemple le code suivant :

 
$w = new XMLWriter();
$w->openUri('php://stdout');
$w->setIndent(true);
$w->setIndentString('    ');
$w->startDocument('1.0', 'utf-8', true);
$w->writePI('xml-stylesheet', 'type="text/xsl" media="screen" href="test.xsl"');
$w->writeComment('Exemple');
$w->startElementNS('rdf', 'RDF', 'http://www.w3.org/1999/02/22-rdf-syntax-ns#');
$w->writeAttributeNS('xmlns', 'skos',  null, 'http://www.w3.org/2004/02/skos/core#');
$w->startElement('skos:Concept');
$w->writeAttribute('rdf:about', '#truc');
$w->startElement('skos:prefLabel');
$w->writeAttribute('xml:lang', 'fr');
$w->text('truc');
$w->endElement(); 
$w->endElement(); 
$w->startElement('skos:Concept');
$w->writeAttribute('rdf:about', '#bidule');
$w->startElement('skos:prefLabel');
$w->writeAttribute('xml:lang', 'fr');
$w->text('bidule');
$w->endElement();
$w->endElement();
$w->startElement('skos:Concept');
$w->writeAttribute('rdf:about', '#chouette');
$w->startElement('skos:prefLabel');
$w->writeAttribute('xml:lang', 'fr');
$w->text('chouette');
$w->endElement();
$w->endElement();
$w->endElement();
$w->endDocument();
$w->flush();

produira :

<?xml version="1.0" encoding="UTF-8" standalone="1"?>
<?xml-stylesheet type="text/xsl" media="screen" href="test.xsl"?>
<!--Example-->
<rdf:RDF xmlns:skos="http://www.w3.org/2004/02/skos/core#" xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">
    <skos:Concept rdf:about="#truc">
        <skos:prefLabel xml:lang="fr">truc</skos:prefLabel>
    </skos:Concept>
    <skos:Concept rdf:about="#bidule">
        <skos:prefLabel xml:lang="fr">bidule</skos:prefLabel>
    </skos:Concept>
    <skos:Concept rdf:about="#chouette">
        <skos:prefLabel xml:lang="fr">chouette</skos:prefLabel>
    </skos:Concept>
</rdf:RDF>

Et bien voici la classe JSONWriter qui fonctionne exactement de la même manière à la différence près qu'elle produit du JSON à la place du XML. Il suffit simplement de remplacer la construction par :

require_once 'JSONWriter.php';
$w = new JSONWriter;

Ce qui permettra de générer :

{
    "version": "1.0",
    "encoding": "utf-8",
    "standalone": "yes",
    "<?xml-stylesheet": {
        "$t": "type=\"text\/xsl\" media=\"screen\" href=\"test.xsl\""
    },
    "rdf$RDF": {
        "xmlns$rdf": "http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#",
        "xmlns$skos": "http:\/\/www.w3.org\/2004\/02\/skos\/core#",
        "skos:Concept": [
            {
                "rdf:about": "#truc",
                "skos:prefLabel": {
                    "xml:lang": "fr",
                    "$t": "truc"
                }
            },
            {
                "rdf:about": "#bidule",
                "skos:prefLabel": {
                    "xml:lang": "fr",
                    "$t": "bidule"
                }
            },
            {
                "rdf:about": "#chouette",
                "skos:prefLabel": {
                    "xml:lang": "fr",
                    "$t": "chouette"
                }
            }
        ]
    }
}

Mapping JSON - XML

La conversion XML vers JSON n'est pas à ma connaissance normalisée et il existe donc différente façon de faire. Si le sujet vous intéresse je vous invite à lire cet article : Converting XML to JSON. Celui-ci résume assez bien les différentes pratiques. La classe JSONWriter implémente actuellement la méthode utilisée par Google et décrite sur la page Using JSON in the Google Data Protocol

Problèmes

La méthode Google est simple, facile à comprendre mais elle est limitée. Elle n'intègre pas les Processsing Instruction ni les DTD mais surtout elle ne permet pas l'usage pour une balise d'un attribut et d'une sous balise de même nom.

La classe JSONWriter souffre également de ce défaut, elle ne traite pas non plus les DTD mais par contre elle traite parfaitement les PI en réalisant une association '<?target_of_pi' : 'valeur_pi'.

Évolution

Je ne ferai probablement pas évoluer cette classe, car elle couvre le besoin pour lequel je l'ai écrit. Mais on peut imaginer qu'elle puisse générer du Json façon Yahoo. Et que la méthode flush soit réellement active (Dans la version 1.0, les "flush" intermédiaire sont simplement ignorés).

Téléchargement et code source

Le code source est disponible sur GitHub : http://github.com/touv/JSONWriter

Ou, on peut directement l'installer avec PEAR en s'abonnant au Channel Respear :


% pear channel-discover pear.respear.net
% pear install respear/JSONWriter

07 avril 2010

Initialiser en 30'' un projet Pxxo / Pkgi

Démarrer un nouveau projet depuis rien est une tâche peu courante, et souvent on tente de se rappeler comment on avait procédé la dernière fois. Voici quelques lignes à copier coller pour démarrer en 30 secondes un projet de Pxxo associé à Pkgi sous Linux Debian/Ubuntu.

Création de l'arborescence

Pour pkgi

mkdir coolproj
cd coolproj
svn export https://subversion.cru.fr/pkgi/tags/2.23 pkgi
./pkgi/build

Pour pxxo

cd var
mv www www.old
svn export https://subversion.cru.fr/pxxo/trunk/apps/skel/ www
cd ..
rm var/www/pear.xml
./bin/pkgi-install-pear
./usr/bin/pear install pxxo/Pxxo_Widget_Core
./etc/init.d/appli start
Voilà il ne reste plus qu'à voir le résultat dans votre navigateur préféré.

Mettre le tout sous Subversion

On considére que le répertoire coolproj se trouve dans un répertoire géré par svn.
svn add -N usr/
svn add -N usr/share/
svn add -N usr/share/php/
svn add usr/share/php/pear/
svn revert --depth infinity usr/share/php/pear/tests/ \
                            usr/share/php/pear/docs/ \
                            usr/share/php/pear/data/ \
                            usr/share/php/pear/.depdb \
                            usr/share/php/pear/.depdblock \
                            usr/share/php/pear/.filemap \
                            usr/share/php/pear/.lock
echo "pkgi.env" > .svn/svnignore
echo ".pkgi" >> .svn/svnignore
echo "bin" >> .svn/svnignore
echo "etc" >> .svn/svnignore
echo "tmp" >> .svn/svnignore
svn propset svn:ignore -F .svn/svnignore .
svn add pkgi
svn add -N var
cd var
echo "lib" > .svn/svnignore
echo "cache" >> .svn/svnignore
echo "lock" >> .svn/svnignore
echo "log" >> .svn/svnignore
echo "run" >> .svn/svnignore
echo "*.old" >> .svn/svnignore
svn propset svn:ignore -F .svn/svnignore .
svn add -N www
cd www
svn add classes/ templates/ index.php .htaccess
svn add -N tmp
cd tmp
svn add .htaccess index.php
cd ..
svn add -N rsc
cd rsc
svn add .htaccess index.php
echo "*.png" > .svn/svnignore
echo "*.gif" >> .svn/svnignore
echo "*.jpg" >> .svn/svnignore
echo "*.pdf" >> .svn/svnignore
echo "*.js" >> .svn/svnignore
echo "*.css" >> .svn/svnignore
echo "*.ico" >> .svn/svnignore
echo "*.txt" >> .svn/svnignore
svn propset svn:ignore -F .svn/svnignore .
cd ../../../usr
echo "bin" > .svn/svnignore
echo "etc" >> .svn/svnignore
echo "lib" >> .svn/svnignore
echo "sbin" >> .svn/svnignore
svn propset svn:ignore -F .svn/svnignore .
cd share
svn add -N locale doc
cd php/pear
echo "docs" > .svn/svnignore
echo ".filemap" >> .svn/svnignore
echo ".depdb" >> .svn/svnignore
echo "tests" >> .svn/svnignore
echo ".depdblock" >> .svn/svnignore
echo ".lock" >> .svn/svnignore
echo "data" >> .svn/svnignore
svn propset svn:ignore -F .svn/svnignore .
cd ../../../..
svn up
svn commit -m "init pxxo/pkgi"


That's all folks!

30 mars 2010

Numéroter automatiquement des branches svn

Créer une nouvelle version sur un projet géré par Subversion, c'est très souvent créer une nouvelle branche. Afin d'harmoniser le nom des branches on peut être tenté de respecter une convention de nommage et de les numéroter.

Exemple de structure attendue

`-----trunk
 |      `-----fichier1
 |      `-----fichier2
`-----branches
        `-----VERSION_1
        |     `-----fichier1
        |     `-----fichier2
        `-----VERSION_1_1
        |     `-----fichier1
        |     `-----fichier2
        `-----VERSION_2
              `-----fichier1
              `-----fichier2

mkbranch

Cette procédure devant être répétée à chaque nouvelle version, il est intéressant d'automatiser cette procédure. Voici donc le script mkbranch qui permet de créer des branches versionnées pour n'importe quel répertoire présent dans le trunk d'un dépôt subversion.

#!/bin/sh
# @author Nicolas Thouvenin 
# @link http://github.com/touv/misc/blob/master/mkbranch
SCRIPT_NAME=`basename $0`
SCRIPT_PATH=`dirname $0`

usage() {
cat <<EOF

    SYNTAXE :
        ${SCRIPT_NAME} [ [-n|--new] |
                         [-u|--update] |
                         [[-v|--version] VERSION ]
                       ] REPERTOIRE

    DETAILS :
        Création d'une branche versionnée sur un répertoire sous le contrôle de svn

        --new     : Bascule majeur, création d'un nouveau numéro de version
        --update  : Bascule minueur, création d'une sous version
        --version : Force le numéro de version (très utile en cas de problème)


    EXEMPLES :
        $SCRIPT_NAME .
        $SCRIPT_NAME -n trunk
        $SCRIPT_NAME -u trunk/module
        $SCRIPT_NAME --update trunk/module 
        $SCRIPT_NAME --version VERSION_4_2 module

EOF
    exit 0;
}

PREFIX="VERSION"          # Préfix du nom de chaque branche
SEPARATOR="_"             # Séparateur entre le préfix et les numéros majeurs et mineurs


VERSION=""
ACTION=""
MODULE=""
NEXT=""
for argument in $*
do
 if [ ! -z "${NEXT}" ]
 then
  CMD="if [ -z \"\${${NEXT}}\" ]; then export ${NEXT}=\"${argument}\"; else export ${NEXT}=\"\${${NEXT}} ${argument}\"; fi;"
  eval ${CMD}
  NEXT=""
 else
  case $argument in
   -h | --help )
   usage
   ;;
   -n | --new )
   ACTION="new"
   ;; 
   -u | --update )
   ACTION="upd"
   ;; 
   -v | --version )
   NEXT="VERSION"
   ;; 
   * )
   MODULE=$argument
   ;;
  esac
 fi
done


VERSION=${VERSION:=}
ACTION=${ACTION:=upd}
SKIPPING=${ACTION:=}

if test ${#} -eq 0
then
 usage
fi
if test "x${MODULE}" = "x"
then
 usage
fi
TRUNK=`svn info --xml ${MODULE} | grep "<url>" | sed -e "s/<url>//" -e "s/<\/url>//"`/
if test "x${TRUNK}" = "x/"
then
 usage
fi
BRANCHES=`echo ${TRUNK} | sed -e "s/\/trunk/\/branches/"`
if test "${TRUNK}" = "${BRANCHES}"
then
 usage
fi
echo "Dépôt trouvé : ${TRUNK}"
if test "x${VERSION}" = "x" 
then
 echo "Calcul du nouveau numéro de version ..."
 AWK=`echo "awk '\$""0 !~ /${SEPARATOR}/ { print \$""0\"${SEPARATOR}0\"} $""0 ~/${SEPARATOR}/ { print $""0}'"`
 MAJEUR=`svn list ${BRANCHES}/ | grep "${PREFIX}${SEPARATOR}"  | sed -e"s/\///" -e"s/${PREFIX}${SEPARATOR}//" | eval ${AWK} | sed -e"s/${SEPARATOR}/ /" | sort -n | cut -f 1 -d " " | tail -1`
 MINEUR=`svn list ${BRANCHES}/ | grep "${PREFIX}${SEPARATOR}"  | sed -e"s/\///" -e"s/${PREFIX}${SEPARATOR}//" | eval ${AWK} | sed -e"s/${SEPARATOR}/ /" | sort -n | cut -f 2 -d " " | tail -1`
 
 if test "x${MAJEUR}" = "x"
 then 
  MAJEUR="0"
 fi
 if test "x${MINEUR}" = "x"
 then
  MINEUR="0"
 fi

 echo "Version trouvée : ${PREFIX}${SEPARATOR}${MAJEUR}${SEPARATOR}${MINEUR}"

 if test "x${ACTION}" = "xupd" 
 then
  MINEUR=`expr $MINEUR + 1 2>/dev/null`
  VERSION="${PREFIX}${SEPARATOR}${MAJEUR}${SEPARATOR}${MINEUR}"
 elif test "x${ACTION}" = "xnew"
 then
  MAJEUR=`expr ${MAJEUR} + 1 2>/dev/null`
  VERSION="${PREFIX}${SEPARATOR}${MAJEUR}"
 fi
fi

echo "Nouveau numéro  : ${VERSION}"
echo "Confirmer le branchage  (O/N)"
read -r CONFIRM
if test "x${CONFIRM}" != "xO" 
then
 echo "Branchage abandonné !"
 exit 1
fi
echo "Branchage de ${MODULE} en ${VERSION} ..."
svn cp ${TRUNK} ${BRANCHES}${VERSION}/ -m "$0 ${VERSION}"
exit $?

Téléchargement et code source

Le code source de ce script est consultable et téléchargeable depuis GitHub à cette adresse http://github.com/touv/misc/blob/master/mkbranch

Remarques

  • Ce script a uniquement été testé sous Ubuntu et Debian sur des dépôts svn distants. Il n'y a pas raison qui ne fonctionne pas sur d'autres distribution et sur des dépôts locaux, mais je ne peux pas l'affirmer.
  • Le nom des branches est paramétrable suivant cette régle : ${PREFIX}${SEPARATEUR}${NUMERO}${SEPARATEUR}${NUMERO}
  • Le script peut être renommé indifféremment.