Un release Beta de PHP 5.4 vient de voir le jour. Tous etes invitees a tester afin de contribuer au reportings de bugs avant le prochain release. n’oubliez donc pas vos « make test » lors de la compilation.

Quelques notes sur les ajouts :

- arret du support de putenv()

- le driver mysqlnd prend le defaut au lieu de mysql

- callable, un nouveau mot cle qui permet de passer des fonctions de rappel en argument d’une fonction.

Source : http://downloads.php.net/stas/
Source Windows : http://windows.php.net/qa/

L’article explique les différentes méthodes de paiement, ainsi que la façon de faire, en utilisant l’API, pour communiquer avec ces services.

Consulter le tutoriel :  http://www.webappers.com/2011/09/08/how-to-get-started-with-the-paypal-api/

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

PHP2yUML est un Script CLI Open source qui reverse-engineere votre code PHP5 et génère un diagramme de classe YUML.me. Puisque le script est au niveau de la ligne de commande, il peut facilement être utilisé au niveau des outils d’integration continue pour générer de la documentation automatique de vos projets.

PHP2yUML supporte les notions de Classes, Interfaces, visibilite des propriétés et méthodes, heritage et dépendances.

Installation

L’installation est simple via git :

git clone git://github.com/bachkoutou/php2yuml.git

 Utilisation de base

Il suffit se spécifier au script un répertoire source avec l’option -f, ainsi qu’un fichier image de destination. voici un exemple :

php php2yuml.php -f test -o diagram.png

Documentation détaillée et exemples d’utilisation

Pour des exemples plus complets, couvrant les options de yuml.me, l’autoload de vos classes etc, vous pouvez accéder a la page Github Du projet : http://bachkoutou.github.com/php2yuml/

Si vous utilisez twitter sur iPhone, vous vous serez peut etre rendus compte que leur application web (si vous visitez twitter via votre navigateur web) est assez fluide. Eh bien, les gens chez twitter ont release en Open source le code qu’ils utilisent pour cette application : Bootstrap. Bootstrap est un ensemble d’outils front-end pour vos applications web. C’est une collection de styles CSS et de conventions HTML. Le « framework » couvre la typographie, les formulaires, les boutons, les tables et grilles, la navigation etc. La taille est relativement petite (6k avec gzip).

Bootstrap est hébergé sur  Github il utilise aussi LessCSS qui est un pre-processeur qui offre plus de flexibilite au code CSS (declarations imbriquees, variables, fonctions etc.).

Pour ceux qui ne desirent pas compiler a la main leurs versions de PHP en parallèle, et qui veulent tester leur codes sur plusieurs versions (incluant des sous versions) de PHP, phpfarm est la pour les aider.

L’installation est tres simple, via Git :

$ git clone git://git.code.sf.net/p/phpfarm/code phpfarm

Il suffit d’executer la commander suivante par la suite, pour changer/installer votre version courante de PHP :

$ cd phpfarm/src/
$ ./compile.sh 5.3.8
$ ../inst/bin/php-5.3.8 --version
PHP 5.3.8 (cli) (built: Sep 03 2011 00:05:23) (DEBUG)
Copyright (c) 1997-2011 The PHP Group
Zend Engine v2.3.0, Copyright (c) 1998-2011 Zend Technologies

• Le repository Git :  git repository
• Le Wiki : wiki
• Le systeme de tickets ticketing system.

Un plan de realisation, une feuille de marquage, 45 minutes de votre temps, 37 etapes a effectuer. C’est tout ce qu’il vous faut pour realiser votre propre ElePHPant de Papier!  El Roubio presente un post tres cool  avec un Fichier PDF qui contient les maquettes ainsi qu’une Video Youtube qui presente les etapes de realisation. A chacun sont elePHPant!

• Le Post : http://www.elroubio.net/2011/08/elephpant-origami-php-paper-addict/
• Le fichier  http://www.elroubio.net/commun/elePHPant-Origami-130811.pdf

DevetDesign.com est un portail de nouvelles qui portent essentiellement sur le developpement et le design web. Dev et design est une aggregation des actualites, outils, tutoriaux et applications qui font leur apparitions sur la toile. Que vous soyez developpeur, integrateur ou designer d interfaces, vous y trouverez vos ressources preferees!

Voici quelques fonctionnalités que la version 5.4 Alpha1 de PHP offre.

Ajouts

Array Deferencing

La fonctionnalité « Array Deferencing » désigne le chainage des accès aux indices d’un tableau PHP. Un peu de la même façon qu’il est possible de faire un

    class Foo {
        public function bar() { }
    }

    function func() {
        return new Foo();
    }

    func()->bar();

Cette fonctionnalité a été rejetée dans le passe a cause d’incertitudes concernant les « memory leaks ». Maintenant, après un patch récemment ajouté, il est possible de faire

function foo() {
return array(1, 2, 3);
}
echo foo()[2]; // affiche 3

L’utilité d’une telle fonctionnalité est plus visible avec les closures :

$func = function() { return array('a', 'b', 'c'); };
echo $func()[0]; // affiche a

Les Traits

C’est une manière de réutiliser le code. Puisque PHP est un langage a héritage Simple, un trait est une manière de réduire certaines limites de l’héritage simple en autorisant le développeur à réutiliser un certain nombre de méthodes dans des classes indépendantes.
Un trait est semblable à une classe, mais il ne sert qu’à grouper des fonctionnalités d’une manière intéressante. C’est un ajout à l’héritage traditionnel qui autorise la composition horizontale de comportements, c’est à dire l’utilisation de méthodes de classe sans besoin d’héritage.
Imaginons ce cas :

 class ezcReflectionMethod extends ReflectionMethod {
   /* ... */
   function getReturnType() { /*1*/ }
   function getReturnDescription() { /*2*/ }
   /* ... */
 }

 class ezcReflectionFunction extends ReflectionFunction {
   /* ... */
   function getReturnType() { /*1*/ }
   function getReturnDescription() { /*2*/ }
   /* ... */
 }

Vous remarquez que les deux méthodes getReturnType et getReturnDescription sont réécrites du fait qu’il n’y a pas de support d’héritage Multiple. Avec les traits, on peut faire comme suit :

 trait ezcReflectionReturnInfo {
   function getReturnType() { /*1*/ }
   function getReturnDescription() { /*2*/ }
 }

 class ezcReflectionMethod extends ReflectionMethod {
   use ezcReflectionReturnInfo;
   /* ... */
 }

 class ezcReflectionFunction extends ReflectionFunction {
   use ezcReflectionReturnInfo;
   /* ... */
 }

Pour plus d’informations sur les traits : http://www.php.net/manual/fr/language.oop5.traits.php

Support de $this dans les Closures

Dans les versions de PHP inférieures a 5.4, il n’était pas possible de se référer au scope d’une classe depuis une closure. Ceci est rendu possible, le mot clé $this peut être maintenant utilise a l’intérieur d’une closure pour référer les propriétés d’une classe. Exemple:

class A {
  private $value = 1;
  function single_getter($name) {
    return function() use ($name) {
      return $this->$name;
    };
  }
}
class B {
  private $value = 2;
  function test() {
    $a = new A;
    $single_getter = $a->single_getter('value');
    print $single_getter();
  }
} 

$b = new B;
$b->test();
//affiche 1

http://drupal4hu.com présente un tutoriel plus en détail sur cette fonctionnalité.

Appel de methode indirect depuis un array

Cette fonctionnalité permet d’utiliser un array pour effectuer un callback. Le tableau doit être  composé de deux éléments, le premier comme nom d’une classe, le deuxième comme nom de méthode. Exemple :

class Hello {
   public function world($x) {
      echo "Hello, $x\n"; return $this;
   }
}

$f = array('Hello','world');
var_dump($f('you')); // Hello, you

Ajout de http_response_code()

Il est possible de récupérer ou de changer le code de la réponse http avec cette méthode :

// Récupère le code courant de la réponse
var_dump(http_response_code()); // int(200)

// Change le code de la réponse
http_response_code(404);

// Récupère notre nouveau code de réponse
var_dump(http_response_code()); // int(404)

Ajout de header_register_callback()

Cette fonction enregistre une fonction de callback qui sera appelée lorsque PHP ait préparé les en-têtes à envoyer, et avant qu’il ne les envoie. Ce qui permet une manipulation fine des en-têtes avant leur envoi.
Exemple :

header('Content-Type: text/plain');
header('X-Test: foo');

function foo() {
 foreach (headers_list() as $header) {
   if (strpos($header, 'X-Powered') !== false) {
     header_remove('X-Powered-By');
   }
   header_remove('X-Test');
 }
}

$result = header_register_callback('foo');
echo "a";

Syntaxe <?=

Cette syntaxe est désormais possible indépendamment de l’option short_tags. A méditer…

Suppressions

Options ini: register_globals, allow_call_time_pass_reference, et register_long_arrays

Toutes ces options étant dépréciées en PHP 5.3, ils sont supprimes dans 5.4.

Support des magic quotes

Les magic_quotes ne sont plus supportées depuis cette version de PHP.

Fonctions : session_is_registered(), session_register(), et session_unregister()

Ces fonctions sont aussi dépréciées dans PHP 5.3. Utilisez plutôt $_SESSION a la place.

Syntaxe break/continue $var

Ceci n’est désormais plus possible en PHP 5.4

for($i = 0; $i < 3; $i++)
{
    for($j = 0; $j < 3; $j++)
    {
        if($i == 1)
            break 2;
        echo "$i:$j\n";
    }
}

//output
0:0
0:1
0:2

Videola, est une plate-forme de gestion de vidéos open source montée sur drupal. Videola vous permet de développer un portail de vidéos complet, incluant:

• une gestion de contenu (incluant les vidéos) (drupal)
• du commerce électronique
• une solution de streaming
• des plans d’inscription personnalisés.
• uns support des téléphones intelligents (iOS, Android etc.)

Vous pouvez aussi créer des contenus payants ou protégées, ou les vidéos ne seront affichées qu’aux utilisateurs inscrits a un plan défini par l’administrateur du site. La plate-forme vous permet aussi de faire la publicité pour ces vidéos protégées en affichant des images ou des vidéos de preview.

Éventuellement, les vidéos sont taguées et catégorisées et le support des vidéos populaires ou similaires est la.

• Demonstration : http://drupalize.me/
• Telechargement : https://github.com/Lullabot/videola
• Solution hosted : http://www.videola.tv/hosted.html