Subversion Repositories Applications.framework

<?php
// declare(encoding='UTF-8');
/**
 * Config permet de charger automatiquement les fichiers ini du Framework et de l'application.
 * Elle offre l'accès en lecture seule aux paramètres de config.
 * C'est une Singleton.
 *
 * PHP Version 5
 *
 * @category  PHP
 * @package   Framework
 * @author      Jean-Pascal MILCENT <jpm@tela-botanica.org>
 * @copyright 2009 Tela-Botanica
 * @license   GPL-v3 et CECILL-v2
 * @version   SVN: <svn_id>
 * @link          /doc/framework/
 */

class Config {

        /**
         * instance de la classe pointant sur elle même (pour le pattern singleton)
         */
        private static $instance = null;

        /**
         * paramètres de configuration
         */
        private static $parametres = array();

        /**
         * Constructeur vide
         */
        private function __construct() {
                // Définition de paramètres avant chargement du config.ini
                self::$parametres = array(
                        'fw_fichier_config' => 'config%s.ini',
                        'fw_chemin' => dirname(__FILE__).DS
                        );

                // Chargement du fichier config.ini du Framework
                $existe = self::parserFichierIni(self::$parametres['fw_chemin'].sprintf(self::$parametres['fw_fichier_config'], ''));
                if ($existe === false) {
                        trigger_error("Veuillez configurer le Framework en renommant le fichier config.defaut.ini en config.ini.", E_USER_ERROR);
                }

                // Chargement du fichier config.ini par défaut de l'application
                $chemin_config_defaut_appli = self::$parametres['chemin_configurations'].sprintf(self::$parametres['fw_fichier_config'], '');
                self::parserFichierIni($chemin_config_defaut_appli);

                // Chargement des fichiers config.ini contextuels
                if (PHP_SAPI == 'cli') {// mode console
                        foreach ($_SERVER['argv'] as $cle => $valeur) {
                                if ($valeur == '-contexte') {
                                        chargerFichierContexte($_SERVER['argv'][($cle+1)]);
                                        break;
                                }
                        }
                } else {// mode web
                        // Pour Papyrus
                        if (defined('PAP_VERSION')) {
                                self::chargerFichierContexte('papyrus');
                        }
                        // Via le fichie .ini par défaut de l'appli
                        if (Config::existeValeur('info.contexte', self::$parametres)) {
                                self::chargerFichierContexte(Config::get('info.contexte'));
                        }

                        // Chargement du contexte présent dans le GET
                        if (isset($_GET['contexte'])) {
                                self::chargerFichierContexte($_GET['contexte']);
                        }

                        // Chargement du contexte présent dans le POST
                        if (isset($_POST['contexte'])) {
                                self::chargerFichierContexte($_POST['contexte']);
                        }
                }
        }

        /**
         * Charge le fichier de config correspondant au contexte
         * @param string $contexte le contexte
         */
        private static function chargerFichierContexte($contexte) {
                $chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];
                $chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '_'.$contexte);
                self::parserFichierIni($chemin_config_appli_contextuel);
        }

        /**
         * Parse le fichier ini donné en paramètre
         * @param string $fichier_ini nom du fichier ini à parser
         * @return array tableau contenant les paramètres du fichier ini
         */
        private static function parserFichierIni($fichier_ini) {
                $retour = false;
                if (file_exists($fichier_ini)) {
                        $ini = parse_ini_file($fichier_ini, true);
                        $ini = self::analyserTableauIni($ini);
                        self::fusionner($ini);
                        $retour = true;
                }
                return $retour;
        }

        /**
         * fusionne un tableau de paramètres avec le tableau de paramètres global
         * @param array $ini le tableau à fusionner
         */
        private static function fusionner(array $ini) {
                self::$parametres = array_merge(self::$parametres, $ini);
        }

        /**
         * renvoie la valeur demandé grâce une chaine de paramètres
         * @param string $param la chaine de paramètres
         * @param array $config le tableau de paramètre
         * @return string la valeur de la chaine demandée
         */
        private static function getValeur($param, $config) {
                if ($param === null) {
                        return null;
                } else {
                        if (strpos($param, '.') !== false) {
                                $pieces = explode('.', $param, 2);
                                if (strlen($pieces[0]) && strlen($pieces[1])) {
                                        if (isset($config[$pieces[0]])) {
                                           if (is_array($config[$pieces[0]])) {
                                                        return self::getValeur($pieces[1], $config[$pieces[0]]);
                                           }
                                        }
                                }
                        } else {
                                if (isset($config[$param])) {
                                        return $config[$param];
                                }
                        }
                        return null;
                }
        }

        /**
         * Teste si param existe dans le tableau config
         * @param string $param nom du paramètre
         * @param array tableau de configuration
         */
        private static function existeValeur($param, $config) {
                $retour = false;
                if (self::getValeur($param, $config) !== null) {
                        $retour = true;
                }
                return $retour;
        }

        /**
         * Vérifie si l'instance de classe à été crée, si non la crée
         */
        private static function verifierCreationInstance() {
                if (empty(self::$instance)) {
                        self::$instance = new Config();
                }
        }

        /**
         * analyse un tableau de paramètres
         * @param array $config le tableau de paramètres
         * @return array le tableau analysé
         */
        private static function analyserTableauIni($config = array()) {
                foreach ($config as $cle => $valeur) {
                        if (is_array($valeur)) {
                                $config[$cle] = self::analyserTableauIni($valeur);
                        } else {
                                self::evaluerReferences($config, $cle);
                                self::evaluerPhp($config, $cle);
                                self::evaluerCle($config, $cle, $config[$cle]);
                        }
                }
                return $config;
        }

        /**
         * dans le cas des chaine de configuration à sous clé (ex.: cle.souscle)
         * evalue les valeurs correspondantes et crée les sous tableaux associés
         * @param array $config tableau de configuration (par référence)
         * @param string $cle la cle dans le tableau
         * @param string $valeur la valeur à affecter
         */
        private static function evaluerCle(&$config, $cle, $valeur) {
                if (strpos($cle, '.') !== false) {
                        unset($config[$cle]);
                        $pieces = explode('.', $cle, 2);
                        if (strlen($pieces[0]) && strlen($pieces[1])) {
                                if (!isset($config[$pieces[0]])) {
                                        if ($pieces[0] === '0' && !empty($config)) {
                                                // convert the current values in $config into an array
                                                $config = array($pieces[0] => $config);
                                        } else {
                                                $config[$pieces[0]] = array();
                                        }
                                } elseif (!is_array($config[$pieces[0]])) {
                                        throw new ErrorException("Ne peut pas créer de sous-clé pour '{$pieces[0]}' car la clé existe déjà");
                                }
                                $config[$pieces[0]] = self::evaluerCle($config[$pieces[0]], $pieces[1], $valeur);
                        } else {
                                throw new ErrorException("Clé invalide '$cle'");
                        }
                } else {
                        $config[$cle] = $valeur;
                }
                return $config;
        }

        /**
         * Evalue les valeurs de références à une clé dans le tableau config (cas du ref:cle)
         * @param array $config tableau de configuration
         * @param string $cle la clé dont il faut évaluer les références
         */
        private static function evaluerReferences(&$config, $cle) {
                if (preg_match_all('/{ref:([A-Za-z0-9_-]+)}/', $config[$cle], $correspondances,  PREG_SET_ORDER)) {
                        foreach ($correspondances as $ref) {
                                $config[$cle] = str_replace($ref[0], self::getValeur($ref[1], $config), $config[$cle]);
                        }
                }
        }

        /**
         * Evalue le code php contenu dans un clé tu tableau config
         * @param array $config tableau de configuration (par référence)
         * @param string $cle le clé du tableau dont il faut évaluer la valeur
         */
        private static function evaluerPhp(&$config, $cle) {
                if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) {
                        eval('$config["'.$cle.'"] = '.$correspondances[1].';');
                }
        }

        /**
         * Charge un fichier ini dans le tableau des paramètres de l'appli
         * @param string $fichier_ini le nom du fichier à charger
         * @return array le fichier ini parsé
         */
        public static function charger($fichier_ini) {
                self::verifierCreationInstance();
                return self::parserFichierIni($fichier_ini);
        }

        /**
         * Acesseur pour la valeur d'un paramètre
         * @param string $param le nom du paramètre
         * @return string la valeur du paramètre
         */
        public static function get($param = null) {
                self::verifierCreationInstance();
                return self::getValeur($param, self::$parametres);
        }

        /**
         * Vérifie si la valeur d'un paramètre existe
         * @param string $param le nom du paramètre
         * @return boolean vrai si le paramètre existe, false sinon
         */
        public static function existe($param) {
                self::verifierCreationInstance();
                return self::existeValeur($param, self::$parametres);
        }
}
?>