En Général, un itérateur n’est rien d’autre qu’un générateur de séquence.

A la base, une séquence est une liste ordonnée de valeurs. Ces valeurs peuvent être répétées dans la liste plusieurs fois, et il n’est pas nécessaire qu’elle soient ordonnées.

Le type le plus basique de séquence en programmation est le tableau. Les éléments d’un tableau peuvent avoir de n’importe quelle valeur, et peuvent etre positionnees arbitrairement. Toutefois, une fois ils sont placées, le tableau a un ordre défini.

Si on parcoure ce tableau, chaque boucle aura l’élément prochain dans la séquence, jusqu’à ce que l’on arrive à la fin de ces éléments.

    foreach ($array as $key => $value) {
        echo $value;
    }

Si nous aurions parcouru ce tableau manuellement, nous aurions écrit une boucle for :

    for ($i = 0; $i < count($array); $i++) {
        echo $array[$i];
    }

A la première itération, la valeur de $i est 0,
On teste ensuite si $i est inferieure à la taille du tableau.
On execute par la suite le corps de la boucle.
Finalement, on incremente $i, et on retourne à l’itération 2.

Sans le réaliser, chaque fois que vous écrivez une boucle for comme ceci, vous construisez un itérateur.

Un itérateur n’est rien que l’abstraction de la boucle for.
Nous avons une méthode « rewind() », qui est la même chose qu’initiaiser $i a 0
Nous avons une méthode « valid() », qui joue le même rôle que le test si $i est inférieure à la taille du tableau.
Nous avons une méthode « next() » qui est la même chose qu’incrèmenter $i.
Et finalement, nous avons deux fonctions qui sont utiles dans le corps de la boucle :
la méthode « key() », qui joue le role de recuperer la valeur de $i.
et la méthode « current() » qui recupere la valeur de l’élément a l’index $i.

Donc, si on réécrivait notre boucle avec les itérateurs, ca ressemblerait à quelque chose du genre :

    for ($it->rewind(); $it->valid(); $it->next()) {
        $current = $it->current();
        echo $current;
    }

En réalité, c’est tout ce que la boucle « foreach » fait à l’interne! À l’exception que foreach expose $key et $value automatiquement pour nous.
Donc, notre code original de foreach devient :

    foreach ($it as $key => $value) {
        echo $value;
    }

Notez bien qu’il est presque identique que le premier foreach!
Lorsqu’on utilise foreach, les tableaux et les itérateurs sont interchangeables.

Construisons donc notre premier vrai itérateur. Construisons notre boucle for comme un itérateur :

    class ForLoopIterator implements Iterator {
        protected $array;
        protected $i = 0;
        public function __construct(array $array) {
            $this->array = $array;
        }
        public function rewind() {
            $this->i = 0;
        }
        public function valid() {
            return isset($this->array[$this->i]);
        }
        public function next() {
            $this->i++;
        }
        public function key() {
            return $this->i;
        }
        public function current() {
            return $this->array[$this->i];
        }
    }

Premièrement, Notre classe doit implémenter l’interface Iterator. Cette interface définit les 5 méthodes que nous avons besoin. Mais aussi, elle offre une logique (implémentée dans le langage) qui nous permet d’utiliser l’itérateur dans les construits foreach.

A part ça, cette classe ressemblerait à une facon plus expressive d’une boucle for.

Il est important aussi de noter qu’en pratique, nous n’allons pas écrire cette classe. Nous allons plutôt utiliser la classe core ArrayIterator qui fait essentiellement la même chose.

Donc, maintenant que nous avons notre concept d’itérateur basique, nous pouvons voir comment l’utiliser.

L’un des bénéfices d’utiliser un itérateur est qu’on peut optimiser l’utilisation de memoire en generant uniquement les valeurs dont on a besoin, lorsqu’elles sont necessaires.

Par exemple, essayons de generer une séquence Fibonacci.

    class Fib implements Iterator {
        protected $a = 0;
        protected $b = 1;
        protected $i = 0;
        public function rewind() {
            $this->a = 0;
            $this->b = 1;
            $this->i = 0;
        }
        public function next() {
            $tmp = $this->b;
            $this->b = $this->a + $this->b;
            $this->a = $tmp;
            $this->i++;
        }
        public function valid() {
            return true;
        }
        public function key() {
            return $this->i;
        }
        public function current() {
            return $this->b;
        }
    }

Vous pouvez construire un itérateur qui va uniquement générer une valeur à chaque fois.
Le gros bénéfice est qu’on peut produire un nombre infini de valeurs, sans que la consommation mémoire augmente au fure et a mesure.

Un autre bénéfice d’utiliser un itérateur est que nous pouvons décorer ce dernier pour fournir des fonctionnalités additionnels.

Par exemple, si nous voulons itérer sur les valeurs paires sur le tableau precedent. Avec les tableaux, nous devons utiliser array_filter et donc dupliquer le tableau.
Par contre, avec les itérateurs, nous pouvons simplement utiliser la Classe core CallbackFilterIterator.

    $it = new CallbackFilterIterator($it, function($value) { return $value % 2 == 0; });

La partie cool ici est que la structure du tableau original n’est jamais changée ou dupliquée. L’Itérateur va uniquement utiliser la méthode next() sur l’itérateur core jusqu’à trouver la valeur voulue.

La librairie SPL de PHP contient un nombre interessant de ce type de décorateurs que vous pouvez utiliser pour optimiser le comportement de vos itérateurs.

Maintenant, vous avez peut etre remarqué que les itérateurs ne sont pas typiquement des petites classes, leur implementation est assez verbeuse.

Par ailleurs, vous pouvez donner le comportement « traversable » a votre classe dans une boucle foreach en implémentant IteratorAggregate :

    interface IteratorAggregate extends Traversable {
        public function getIterator();
    }

L’interface IteratorAggregate permet d’instancier un itérateur different de votre classe. Supposons que votre classe a un tableau que vous voulez boucler dessus.

Au lieu de construire un nouvel itérateur dans votre classe, il faut simplement implementer IteratorAggregate :

    class MyClass implements IteratorAggregate {
        protected $myArray = array();
        public function getIterator() {
            return new ArrayIterator($this->myArray);
        }
    }

Maintenant, nous pouvons utiliser une instance de notre classe dans un foreach!
Les itérateurs sont un concept tres puissant qui, si utilisé comme il faut, permettre d’avoir un code propre et flexible!

La video originale d’Anthony Ferrara (Anglais) : http://www.youtube.com/watch?v=tW6GcZjBc3E&feature=share&list=PLM-218uGSX3DQ3KsB5NJnuOqPqc5CW2kW

Derby MVC framework permet d’ecrire des applications collaboratifs en realtime, qui fonctionnent sur node.js ainsi que sur les navigateurs clients. Le framework offre un engin de synchronisation de donnees appelé Racer, qui synchronise automatiquement les donnees entre les navigateurs et les serveurs, ainsi qu’une base de donnees. Les modeles souscrivent a des objets specifiques, permettant ainsi le controle granulaire sur la propagation de donnees sans definir des canaux de transfert.

Racer permet l’utilisation offline et la resolution de conflits, ce qui offre un grand plus. Les applications Derby peuvent etre indexés par les moteurs de recherche puisque les templates s’affichent sur le serveur et le client. De plus, les templates definissent les « bindings », ce qui permet de mettre a jour instantanement la vue suite au changement de modele et vice-versa.

Requirements: Node.js Framework
Demo: http://derbyjs.com/
License: MIT License

Deployd est une platforme qui facilite la creation d’APIs REST. Avec Deployd, vous pouvez creer une API exploitable en quelques minutes! vous n’avez aucun serveur a installer, aucune configuration a faire.  faites simplement installer Deployd, et vous etes pret pour votre premiere API.

A part la creation de ressources via une interface graphique, Deployd expose aussi un objet Javascript du coté client, qui facilite l’inspection du code. le tout est sous license gratuite apache.

Nécessite : -
Demo: http://www.deployd.com/
License: Apache License

Recline.js est une application en Javascript pour concevoir des applications dediees aux donnees. L’application est dotee d’un framework qui expose des librairies d’acces aux donnees (DataSet, Record, Field) ainsi que des vues pour les afficher (Grille, Carte, timeline,  etc.)

La librairie offre plusieurs wrappers pour communiquer avec des serveurs de donnees comme :

• Elastic Search
• Google docs
• Couch DB
• Data Proxy
• etc.

Necessite : Backbone Framework
Demo: http://reclinejs.com/
License: MIT License

Article Web Appers original (en anglais) : http://www.webappers.com/2012/07/10/a-powerful-library-for-data-heavy-applications/

Balloons.IO est un serveur de chat multi-salles, et dispose d’un client pret a l’utilisation. la plateforme est conçue sur la base de Node.JS, Express, Socket.IO et Redis. Balloons dispose aussi de plugins d’authentification OAuth (utilisable avec Twitter par exemple.) L’interface est tres clean et personnalisable avec CSS. Le tout est sous license MIT, vous pourrez donc l’installer sur votre serveur gratuitement et facilement.

Nécessite: Node.js, Redis
Demo: https://github.com/gravityonmars/Balloons.IO
License: MIT License

Article Web Appers original (en anglais) : http://www.webappers.com/2012/06/12/open-source-chat-rooms-web-application-with-node-js/

Sigma.js est une librairie Javascript Open source, qui vous aide a dessiner des graphes en utilisant les canvas HTML5. La librairie a ete concue pour partager des cartes interactives sur vos pages web ainsi que d’explorer dynamiquement une base de donnees reseau.  La license de la librairie est sous MIT License.

Nécessite : Javascript
Demo: http://sigmajs.org/
License: MIT License

Article Web Appers original (en anglais) : http://www.webappers.com/2012/06/13/sigma-js-draw-graphs-using-html5-canvas-element/

Streak est un service qui vous permet de tracker vos bugs, taches etc directement depuis votre gestionnaire de mails (Gmail). L’application de cet outil va du support a la clientele aux services de ventes en passant par les services d’IT etc. L’application offre des fonctionnalités pour envoyer les messages a une date prédéterminée, d’avoir un tableau de bord sur les activités reliées a votre projet. Streak ajoute un niveau d’organisation dans votre email mais le stockage se fait securitairement dans leur cloud.

Requirements: -
Demo: http://www.streak.com/
License: License Free

Article Web Appers original (en anglais) : http://www.webappers.com/2012/06/19/bug-tracking-and-customer-support-inside-gmail/

Cet Excellent tutoriel montre comment développer un Graphique a Barre 3D  avec HTML et CSS3. Le graphique est independant du background, Facilement personnalisable, adaptable au nombre de barres choisies.

La démo peut etre visualisée ici : http://tympanus.net/Tutorials/CSS3AnnotationOverlayEffect/

Lire La suite sur CodRops : http://tympanus.net/codrops/2012/05/21/animated-3d-bar-chart-with-css3/

Apprenez comment effectuer des animations d’annotations sur une image avec CSS3 en utilisant la propriété :checked pseudo-class.  http://tympanus.net/codrops/2012/05/14/annotation-overlay-effect-with-css3/.

Dernièrement, j’ai contribué a un projet Open source PHP-OAuth2, qui fournit un client OAuth2 pour PHP5. Le projet est initié et développé par Pierrick Charron et est disponible sur GitHub. Le client permet de se connecter et de consommer n’importe quelle API qui supporte le protocole OAuth2. Dans ce post, nous allons voir comment installer, utiliser et étendre cet outil pour des besoins spécifiques.

Installation

L’installation est simple. Il suffit en fait de récupérer le script via Git :

git clone git://github.com/adoy/PHP-OAuth2.git

Utilisation

Pour utiliser le client, assurez vous tout d’abord que le client est accessible depuis votre code (include, include_path, autoload etc.). Par la suite, vous devez definir 5 constantes :

• CLIENT_ID : votre identifiant client.
• CLIENT_SECRET : votre cle secrete.

vous récupérez ces deux valeurs depuis le serveur OAuth2 (Facebook Apps par exemple)

• REDIRECT_URI : l’url de redirection de votre application.
• AUTHORIZATION_ENDPOINT : L’url du service d’autorisation
• TOKEN_ENDPOINT : L’url du service de recuperation des jetons d’acces.

require('client.php');

const CLIENT_ID     = 'your client id';
const CLIENT_SECRET = 'your client secret';

const REDIRECT_URI           = 'http://url/of/this.php';
const AUTHORIZATION_ENDPOINT = 'https://graph.facebook.com/oauth/authorize';
const TOKEN_ENDPOINT         = 'https://graph.facebook.com/oauth/access_token';

$client = new OAuth2\Client(CLIENT_ID, CLIENT_SECRET);
if (!isset($_GET['code']))
{
    $auth_url = $client->getAuthenticationUrl(AUTHORIZATION_ENDPOINT, REDIRECT_URI);
    header('Location: ' . $auth_url);
    die('Redirect');
}
else
{
    $params = array('code' => $_GET['code'], 'redirect_uri' => REDIRECT_URI);
    $response = $client->getAccessToken(TOKEN_ENDPOINT, 'authorization_code', $params);
    parse_str($response['result'], $info);
    $client->setAccessToken($info['access_token']);
    $response = $client->fetch('https://graph.facebook.com/me');
    var_dump($response, $response['result']);
}

Explication

On instancie tout d’abord le client en lui passant l’identification du client ainsi que la cle secrète. Il y a deux cas a gérer par la suite:

1. En accédant au script (sans spécifier de code dans l’url), on récupère l’url d’authentification via la méthode getAuthenticationUrl(), et on redirige l’utilisateur vers cette addresse (Dans notre exemple, c’est l’adresse d’authentification de l’utilisateur sur Facebook).
2. Une fois l’utilisateur authentifié, le serveur le redirige vers notre script en lui fournissant un code d’accès. Dans ce cas, en récupérant le code depuis $_GET, nous allons récupérer un jeton d’accès depuis le service de récupération de jetons. Ceci est effectué via la méthode getAccessToken().
3. Une fois le jeton d’accès récupéré, il est alors possible de consommer l’api via la méthode fetch().

Assez simple non?

Comment je peux définir des nouveaux types d’accès ?

Si vous utilisez l’API de Facebook, vous n’avez probablement pas besoin d’utiliser ce genre d’opérations. Dans le cas ou vous connectez a un autre service, il est possible que ce dernier vous offre des modes d’accès personnalisés. Il est alors possible d’étendre le client OAuth2 pour supporter ces appels. Il suffit d’écrire alors une nouvelle classe pour ce faire. Voici un exemple :

namespace OAuth2\GrantType;

/**
 * MyCustomGrantType Grant Type
 */
class MyCustomGrantType implements IGrantType
{
    /**
     * Defines the Grant Type
     *
     * @var string  Defaults to 'my_custom_grant_type'.
     */
    const GRANT_TYPE = 'my_custom_grant_type';

    /**
     * Adds a specific Handling of the parameters
     *
     * @return array of Specific parameters to be sent.
     * @param  mixed  $parameters the parameters array (passed by reference)
     */
    public function validateParameters(&$parameters)
    {
        if (!isset($parameters['first_mandatory_parameter']))
        {
            throw new \Exception('The \'first_mandatory_parameter\' parameter must be defined for the Password grant type');
        }
        elseif (!isset($parameters['second_mandatory_parameter']))
        {
            throw new \Exception('The \'seconde_mandatory_parameter\' parameter must be defined for the Password grant type');
        }
    }
}

Vous pouvez alors utiliser la méthode getAccessToken en lui spécifiant le nouveau type d’accès :

$response = $client->getAccessToken(TOKEN_ENDPOINT, 'my_custom_grant_type', $params);

Si vous avez des questions ou des commentaires sur l’utilisation du script ou par rapport au protocole OAuth2, n’hesitez pas!

• Téléchargement : git clone git://github.com/adoy/PHP-OAuth2.git
• Documentation : https://github.com/adoy/PHP-OAuth2