L’addon se nomme Clover et vous pourrez le télécharger ici

Taille : 2.4 MB
Compatible : Windows XP / Vista / Vista64 / 7 / 7 x64

La problématique:
Comment visualiser le contenu des variables PHP en runtime.

Combien de fois ais-je perdu des heures à chercher le pourquoi d’un bug à cause de variables php non visibles.
Combien de fois ai-je collé des echo par ci et par là dans mes codes pour tenter de voir le contenu de mes variables php.

Obligeant d’aller ensuite visualiser le code source de la page html dans le navigateur.

Je ne rencontrais pas ce souci avec javascript. L’excellent outil Firebug permettant de visualiser directement les variables et leur contenu en runtime (quitte à ajouter un point d’arrêt ou utiliser le mode pas à pas), et même de logguer des messages en console avec console.log().
Du coup il m’en venu l’idée de passer des informations de PHP à la console de firebug !
Au départ une simple insertion de script php qui rédigeait un script js de console.log, j’ai soumis cette idée à Cahnory sur le chat qui s’est empressé d’en faire une petite classe que j’ai a mon tour lègèrement modifiée.
Je vous en soumet le premier jet:

class FfxConsoleDebug
  {
    private $dumps = array();
    
    static private function getEmptyDump($type = 'log', $back = 1) {
      $d    = debug_backtrace();
      return array(
        'type'  => $type,
        'file'  => $d[$back]['file'],
        'line'  => $d[$back]['line']
      );
    }
    
    public function dump($var) {
      $vars = func_get_args();
      $dump = self::getEmptyDump();
      $dump['vars'] = array();
      foreach($vars as $key => $value) {
        if(is_object($value) && !is_a($value, 'stdClass')) {
          $value = array(
            'class' => get_class($value),
            'id'    => spl_object_hash($value),
            'attr'  => get_object_vars($value)
          );
        }
        $dump['vars'][]   = $value;
      }
      $this->dumps[] = $dump;
    }
    
    public function warn($warning) {
      $dump = self::getEmptyDump('warn');
      $dump['msg'] = $warning;
      $this->dumps[]   = $dump;
    }
    
    public function alert($alert) {
      $dump = self::getEmptyDump('alert');
      $dump['msg'] = $alert;
      $this->dumps[]   = $dump;
    }
    
    public function toJs($json=true) {
      $js = '';
      foreach($this->dumps as $dump) {
        
        switch($dump['type']){
          case 'log' :  $msg=($json)?"',".json_encode((object)$dump['vars']):(preg_replace('~\r?\n~',"\\r\\n",addslashes(var_export($dump['vars'],true))))."'";
                        //$js .='console.info(\'PHP debug line ==============='.$msg.',\''.addslashes($dump['file']).':'.$dump['line'].'\');';
                        $js .='console.info(\'================= PHP debug info ==============='."\\nFile :\t".addslashes($dump['file'])."\\nLine :\t".$dump['line']."\\n".$msg.',\''.':'.'\');';
                        
                        break;
          case 'warn' : $js .= 'console.warn(\'PHP:'.stripslashes($dump['msg'])."\\nFile :\t".addslashes($dump['file'])."\\nLine :\t".$dump['line']."\\n".'\');';
                          break;
          case 'alert': $js .= 'alert(\'PHP ALERT : \n'.stripslashes($dump['msg']).'\');';
                          break;              
                        
        }              
      }
      
      return $js;
    }
    
    public function toHeader() {
      $hash = spl_object_hash($this);
      foreach($this->dumps as $k => $dump) {
        $id = $hash.'-'.$k;
        if($dump['type'] === 'log') {
          header('PHPrint-'.$id.'-source: ' . $dump['file'].' on line '.$dump['line']);
          foreach($dump['vars'] as $i => $v) {
            header('PHPrint-'.$id.'-'.$i.'-value: '. json_encode($v));
          }
        } else {
          header('PHPrint-'.$id.'-warning: ' . $dump['msg']);
        }
      }
    }
  }
  $debug = new FfxConsoleDebug;
  
  
  //USAGE
  /*
  $d->dump('test','ok');
  $d->dump(array('test'));
  $d->dump($d);
  $d->warn('Ne pas oublier de supprimer les dumps');
   echo '' . $d->toJs( [true/false]) . '';  */

J’ai mis cette classe dans un fichier que j’inclus dans tous mes projets au moyen d’un require()

Il suffit de placer les lignes souhaitées dans le code php à l’endroit ou l’on souhaite visualiser ses variables
Lors de l’affichage dans le navigateur, les lignes de debug apparaissent dans la console firebug avec le numéro de ligne et le nom du fichier.

le paramètre boolean true / false permet:
en mode true (par defaut) d’obtenir un objet dans la console
en mode false d’obtenir un string mis en forme comme un var_export de php

Personnellement cette petit classe m’a fait gagner un temps précieux en me permettant d’avoir un aperçu direct des ce qui se passe au niveau de mes variables php.

Cette technique est également utilisée dans les jeux afin d’animer des personnages en faisant défiler les différentes postures d’un personnage par modification dynamique de la position de l’image.
j’avais déja abordé les animations avec sprite ici

J’ai opté par un système assez simple basé sur les sommes de puissances de 2.

On attribue à chaque module une puissance de 2
On additionne pour chaque utilisateur les sommes des puissances de deux pour les modules autorisés.
Une conversion de la somme en binaire suivi d’un reverse de la chaine obtenue donne une série de 0 et 1 qui dans l’ordre donnent les accès aux modules sous forme de boolean (0= accès refusé , 1 accès autorisé).

Un petit exemple :

Explications:

ici chacun des modules se voit attribuer une puissance de 2 (attention pas de doublon !)

Pour un utilisateur on somme les puissances de deux des modules autorisés

ici les modules compta et documents

Et voici le conversion magique :

qui nous retourne la chaine « 1010 »
que l’on peut décomposer comme suit:
compta 1 => true
fournitures 0 => false
documents 1 => true
admin 0 => false

Par commodité on peut associer à chaque module les boolean d’accès pour l’utilisateur:

ce qui nous donne

$menu[« compta »]=>1
$menu[« fournitures »]=>0
$menu[« documents »]=>1
$menu[« admin »]=>0;

il suffit ensuite de tester pour avoir si le module est autorisé on non

Avantages :
Pas besoin de table, gestion simple des groupes : un groupe = un integer, la même somme donnant les mêmes accès.
Ajout aisé de module : il suffit d’ajouter une puissance de 2

Désavantage :
Devient vite fouillis lorsque l’on a beaucoup de modules

Pour éviter les fautes de goût je vous conseille d’utiliser des outils qui, à partir d’une couleur maitresse, vous indiqueront une palette de couleurs que vous pourrez y associer.

Il existe des sites en ligne que vous trouverez facilement en tapant « color scheme » sur votre moteur de recherche de prédilection.

Mon choix s’est porté sur un petit freeware nommé CSDesigner
Doté d’une pipette qui vous permet de repiquer la couleur maitresse, il vous propose les dégradés et couleurs complémentaires que vous pourrez lui associer sans risques pour les rétines.
Vous trouvez cette petite application ici