SALT > Manuel >
Le framework SALT est basé sur plusieurs concepts : Quelques exemples d'implémentation de ces concepts :

L'utilisation des propriétés dynamiques des objets PHP

Les classes qui les utilisent sont :
Pour la classe In, l'utilisation des méthodes magiques __get et __set est obligatoire car les propriétés sont inconnues lors de la définition de la classe et cela permet également de factoriser tout les getter/setter afin de pouvoir contrôler et transformer une donnée avant stockage ou restitution.

Mais on va plus loin dans ce concept : Il aurait été possible d'implémenter __get et __set afin d'utiliser un tableau dans l'objet stockant les propriétés... mais on peut faire mieux en terme de performance.
En effet, PHP autorise la création de propriétés dynamiques non déclarées sur chaque instance de classe.
Par exemple :     <?php
    class Test {
    }
    $test = new Test();
    $test->a = 'b';
    echo $test->a; // affiche 'b' En utilisant ces propriétés dynamiques dans les méthodes magiques, on peut grandement améliorer les performances lors d'accès multiples à la même donnée.     <?php
    class Test {
        public function __get($var) {
            if (!isset($this->$var)) {
                $this->$var = NULL;
            }
            return $this->$var;
        }
        public function __set($var, $value) {
            $this->$var = $value;
        }
    }
    $test = new Test();
    var_dump($test->a); // appelle __get et affiche NULL
    var_dump($test->a); // affiche NULL sans appeller __get, la propriété étant créée !
    $test->a = 'b';     // appelle __set
    echo $test->a;         // affiche 'b', toujours sans appeler __get ! Cette méthode permet des accès environ 1000 fois plus rapides que si la propriété était stockée dans un tableau.
L'utilisation de propriétés dynamiques non déclarées à tout de même un coût en performance lors du premier accès à la propriété (et donc lors de l'appel à __get ou __set). Si votre application PHP doit créer de nombreux objets avec beaucoup de champs pour n'y accéder qu'une fois, le framework SALT n'est sans doute pas adapté à votre besoin.

Le formatage des données pour leur utilisation

Lorsqu'on utilise une donnée, il faut en général la préparer et la formater.
Pour l'affichage, il faut échapper les caractères pouvant être interprétés en HTML; pour la construction d'une URL, les caractères pouvant être interprétés dans l'URL, etc...
En général les données proviennent de la requête, c'est à dire des tableaux super globaux $_GET et $_POST
Pour gérer tout ca, le framework SALT intègre la classe In.

Cette classe permet de formater une donnée provenant d'un tableau super global.
Par exemple :
    <?php
    $Input = In::getInstance();

    echo $Input->G->HTML->variable; // équivalent de htmlentities($_GET['variable'], ENT_QUOTES, 'UTF-8')
    echo $Input->P->URL->variable2; // équivalent de rawurlencode($_POST['variable2']) Tout les tableaux super globaux sont supportés : GET, POST, FILES, COOKIE, SERVER, REQUEST, ENV avec la 1ère lettre pour accesseur.
Le tableau super global SESSION est accessible via $Input->SS->... afin de ne pas le confondre avec SERVER.
Les formats supportés sont : HTML, URL, B64 (réalise un encodage en base64), RAW (renvoi la valeur sans modification), SQL (réalise un mysql_real_escape_string) ainsi que deux formats spéciaux : ISSET et SET
ISSET permet de vérifier qu'une variable est définie dans le tableau super global indiqué
SET permet de modifier la valeur dans le tableau super global.

Plus d'informations sur la classe In

Enfin, la classe Base contient aussi un mécanisme pour l'affichage des champs des objets mappés.
En utilisant les méthodes Base->VIEW->field et Base->FORM->field on peut afficher respectivement la valeur du champ et un input permettant de modifier le champ.
Par exemple :
    <?php
    use salt\Field;
    use salt\ViewControl;
    use salt\FormHelper;

    class MaClass extends salt\Base {
        protected function metadata() {
            parent::MODEL()
                ->registerId('id')
                ->registerTableName('ma_classe')
                ->registerFields(
                    // on définit 2 champs, "id" et "status"
                    Field::newNumber('id', 'ID')->sqlType('INT PRIMARY KEY AUTO_INCREMENT'),
                    Field::newNumber('status', 'Status', FALSE, 0, array(
                            0=>'Demandé', // pour chaque valeur de status on définit un texte
                            1=>'Refusé',  //   en clair correspondant
                            2=>'Validé'
                    ))
            );
        }
    }

    $maClass = new MaClass();

    echo $maClass->status; // affiche 0 qui est la valeur par défaut du champ status (4eme parametre de Field::newNumber)
    echo $maClass->VIEW->status; // affiche "Demandé", c'est à dire la valeur textuelle correspondant à la valeur du champ
    // nécessaire pour afficher un input de formulaire
        ViewControl::edit(); // passe la page en mode édition
        FormHelper::get(); // créé un formulaire en GET
    echo $maClass->FORM->status; // affiche un select avec les différentes valeurs possibles, la valeur 0 sélectionnée,
                                 // sauf si le formulaire courant redéfinit la variable dans un tableau GET ou POST après un envoi Plus d'informations sur l'affichage des objets

Les informations de debug

Enfin, le framework intègre une classe Benchmark permettant d'enregistrer et d'auditer ce qui se passe lors de l'exécution.
Cette classe permet d'enregistrer des compteurs, des temps, et des informations.
Elle enregistre systématiquement le nombre de requêtes executées, le texte des requêtes et le temps de chaque requête par exemple.
Elle calcule également le temps passé à enregistrer les requêtes, mais cela reste négligeable.

Le framework fournit des exemples qui peuvent être recopiés afin de restituer de manière simple et propre ces informations.
Par exemple, extrait du module SSO :
Rendu Benchmark
Plus d'informations sur la classe Benchmark