1: <?php
  2: // declare(encoding='UTF-8');
  3: /**
  4:  * Config permet de charger automatiquement les fichiers ini du Framework et de l'application.
  5:  * Elle offre l'accès en lecture seule aux paramètres de config.
  6:  * C'est une Singleton.
  7:  * Si vous avez besoin de modifier dynamiquement des paramètres de configuration, utiliser le @see Registe, il est fait pour ça.
  8:  *
  9:  * @category    PHP 5.2
 10:  * @package Framework
 11:  * @author      Jean-Pascal MILCENT <jpm@tela-botanica.org>
 12:  * @copyright   Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)
 13:  * @license http://www.gnu.org/licenses/gpl.html Licence GNU-GPL-v3
 14:  * @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL-v2
 15:  * @version $Id: Config.php 448 2013-12-19 13:37:39Z jpm $
 16:  * @link        /doc/framework/
 17:  */
 18: 
 19: class Config {
 20: 
 21:     /** Instance de la classe pointant sur elle même (pour le pattern singleton). */
 22:     private static $instance = null;
 23: 
 24:     /** Paramètres de configuration. */
 25:     private static $parametres = array();
 26: 
 27:     private function __construct() {
 28:         // Définition de paramètres avant chargement du config.ini
 29:         self::$parametres = array(
 30:             'fichier_config' => 'config%s.ini',
 31:             'chemin_framework' => dirname(__FILE__).DS
 32:             );
 33: 
 34:         // Chargement du fichier config.ini du Framework
 35:         $existe = self::parserFichierIni(self::$parametres['chemin_framework'].sprintf(self::$parametres['fichier_config'], ''));
 36:         if ($existe === false) {
 37:             trigger_error("Veuillez configurer le Framework en renommant le fichier config.defaut.ini en config.ini.", E_USER_ERROR);
 38:         }
 39: 
 40:         // Chargement du fichier config.ini par défaut de l'application
 41:         $chemin_config_defaut_appli = self::$parametres['chemin_configurations'].sprintf(self::$parametres['fichier_config'], '');
 42:         self::parserFichierIni($chemin_config_defaut_appli);
 43: 
 44:         // Chargement des fichiers config.ini contextuels
 45:         if (PHP_SAPI == 'cli') {// mode console
 46:             foreach ($_SERVER['argv'] as $cle => $valeur) {
 47:                 if ($valeur == '-contexte') {
 48:                     self::chargerFichierContexte($_SERVER['argv'][($cle+1)]);
 49:                     break;
 50:                 }
 51:             }
 52:         } else {// mode web
 53:             // Pour Papyrus
 54:             if (defined('PAP_VERSION')) {
 55:                 self::chargerFichierContexte('papyrus');
 56:             }
 57:             // Via le fichie .ini par défaut de l'appli
 58:             if (Config::existeValeur('info.contexte', self::$parametres)) {
 59:                 self::chargerFichierContexte(Config::get('info.contexte'));
 60:             }
 61: 
 62:             // Chargement du contexte présent dans le GET
 63:             if (isset($_GET['contexte'])) {
 64:                 $_GET['contexte'] = strip_tags($_GET['contexte']);
 65:                 self::chargerFichierContexte($_GET['contexte']);
 66:             }
 67: 
 68:             // Chargement du contexte présent dans le POST
 69:             if (isset($_POST['contexte'])) {
 70:                 $_POST['contexte'] = strip_tags($_POST['contexte']);
 71:                 self::chargerFichierContexte($_POST['contexte']);
 72:             }
 73:         }
 74:     }
 75: 
 76:     /**
 77:      * Charge le fichier de config correspondant au contexte
 78:      * @param string $contexte le contexte
 79:      */
 80:     private static function chargerFichierContexte($contexte) {
 81:         $chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];
 82:         $chemin_config_appli_contextuel .= sprintf(self::$parametres['fichier_config'], '_'.$contexte);
 83:         self::parserFichierIni($chemin_config_appli_contextuel);
 84:     }
 85: 
 86:     /**
 87:      * Parse le fichier ini donné en paramètre
 88:      * @param string $fichier_ini nom du fichier ini à parser
 89:      * @return array tableau contenant les paramètres du fichier ini
 90:      */
 91:     private static function parserFichierIni($fichier_ini) {
 92:         $retour = false;
 93:         if (file_exists($fichier_ini)) {
 94:             $ini = parse_ini_file($fichier_ini, true);
 95:             $ini = self::analyserTableauIni($ini);
 96:             $retour = true;
 97:         } else {
 98:             error_log("Fichier de configuration introuvable : $fichier_ini");
 99:         }
100:         return $retour;
101:     }
102: 
103:     /**
104:      * Fusionne un tableau de paramètres avec le tableau de paramètres global
105:      * @param array $ini le tableau à fusionner
106:      */
107:     private static function fusionner(array $ini) {
108:         self::$parametres = array_merge(self::$parametres, $ini);
109:     }
110: 
111:     /**
112:      * Renvoie la valeur demandée grâce une chaîne de paramètres
113:      * @param string $param la chaine de paramètres
114:      * @param array $config le tableau de paramètre
115:      * @return string la valeur de la chaine demandée
116:      */
117:     private static function getValeur($param, $config) {
118:         if ($param === null) {
119:             return null;
120:         } else {
121:             if (isset($config[$param])) {
122:                 return $config[$param];
123:             } else if (strpos($param, '.') !== false) {
124:                 $pieces = explode('.', $param, 2);
125:                 if (strlen($pieces[0]) && strlen($pieces[1])) {
126:                     if (isset($config[$pieces[0]])) {
127:                         if (is_array($config[$pieces[0]])) {
128:                             return self::getValeur($pieces[1], $config[$pieces[0]]);
129:                         }
130:                     }
131:                 }
132:             } else {
133:                 return null;
134:             }
135:         }
136:     }
137: 
138:     /**
139:      * Teste si param existe dans le tableau config
140:      * @param string $param nom du paramètre
141:      * @param array tableau de configuration
142:      */
143:     private static function existeValeur($param, $config) {
144:         $retour = false;
145:         if (self::getValeur($param, $config) !== null) {
146:             $retour = true;
147:         }
148:         return $retour;
149:     }
150: 
151:     /**
152:      * Vérifie si l'instance de classe à été crée, si non la crée
153:      */
154:     private static function verifierCreationInstance() {
155:         if (empty(self::$instance)) {
156:             self::$instance = new Config();
157:         }
158:     }
159: 
160:     /**
161:      * Analyse un tableau de paramètres.
162:      * @param array $config le tableau de paramètres
163:      * @return array le tableau analysé
164:      */
165:     private static function analyserTableauIni($config = array()) {
166:         foreach ($config as $cle => &$valeur) {
167:             if (is_array($valeur)) {
168:                 $config[$cle] = self::analyserTableauIni($valeur);
169:             } else {
170:                 self::evaluerReferences($config, $cle);
171:                 self::evaluerPhp($config, $cle);
172:                 self::evaluerCle($config, $cle, $config[$cle]);
173:             }
174:             self::fusionner($config);
175:         }
176:         return $config;
177:     }
178: 
179:     /**
180:      * Dans le cas des chaine de configuration à sous clé (ex.: cle.souscle)
181:      * évalue les valeurs correspondantes et crée les sous tableaux associés.
182:      * @param array $config tableau de configuration (par référence)
183:      * @param string $cle la cle dans le tableau
184:      * @param string $valeur la valeur à affecter
185:      */
186:     private static function evaluerCle(&$config, $cle, $valeur) {
187:         if (strpos($cle, '.') !== false) {
188:             unset($config[$cle]);
189:             $pieces = explode('.', $cle, 2);
190:             if (strlen($pieces[0]) && strlen($pieces[1])) {
191:                 if (isset($config[$pieces[0]]) && !is_array($config[$pieces[0]])) {
192:                     $m = "Ne peut pas créer de sous-clé pour '{$pieces[0]}' car la clé existe déjà";
193:                     trigger_error($m, E_USER_WARNING);
194:                 } else {
195:                     $config[$pieces[0]][$pieces[1]] = $valeur;
196:                     $config[$pieces[0]] = self::evaluerCle($config[$pieces[0]], $pieces[1], $valeur);
197:                 }
198:             } else {
199:                 $m = "Clé invalide '$cle'";
200:                 trigger_error($m, E_USER_WARNING);
201:             }
202:         } else {
203:             $config[$cle] = $valeur;
204:         }
205:         return $config;
206:     }
207: 
208:     /**
209:      * Évalue les valeurs de références à une clé dans le tableau config (cas du ref:cle).
210:      * @param array $config tableau de configuration
211:      * @param string $cle la clé dont il faut évaluer les références
212:      */
213:     private static function evaluerReferences(&$config, $cle) {
214:         if (preg_match_all('/{ref:([A-Za-z0-9_.-]+)}/', $config[$cle], $correspondances,  PREG_SET_ORDER)) {
215:             foreach ($correspondances as $ref) {
216:                 $config[$cle] = str_replace($ref[0], self::getValeur($ref[1], self::$parametres), $config[$cle]);
217:             }
218:         }
219:     }
220: 
221:     /**
222:      * Évalue le code php contenu dans un clé tu tableau config.
223:      * @param array $config tableau de configuration (par référence)
224:      * @param string $cle le clé du tableau dont il faut évaluer la valeur
225:      */
226:     private static function evaluerPhp(&$config, $cle) {
227:         if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) {
228:             eval('$config["'.$cle.'"] = '.$correspondances[1].';');
229:         }
230:     }
231: 
232:     /**
233:      * Charge un fichier ini dans le tableau des paramètres de l'appli.
234:      * @param string $fichier_ini le nom du fichier à charger
235:      * @return array le fichier ini parsé
236:      */
237:     public static function charger($fichier_ini) {
238:         self::verifierCreationInstance();
239:         return self::parserFichierIni($fichier_ini);
240:     }
241: 
242:     /**
243:      * Accesseur pour la valeur d'un paramètre.
244:      * @param string $param le nom du paramètre
245:      * @return string la valeur du paramètre
246:      */
247:     public static function get($param = null) {
248:         self::verifierCreationInstance();
249:         return self::getValeur($param, self::$parametres);
250:     }
251: 
252:     /**
253:      * Vérifie si la valeur d'un paramètre existe.
254:      * @param string $param le nom du paramètre
255:      * @return boolean vrai si le paramètre existe, false sinon
256:      */
257:     public static function existe($param) {
258:         self::verifierCreationInstance();
259:         return self::existeValeur($param, self::$parametres);
260:     }
261: 
262:     /**
263:      * Vérifie que tous les paramêtres de config nécessaires au fonctionnement d'une classe existe dans les fichiers
264:      * de configurations.
265:      * L'utilisation de cette méthode depuis la classe Config évite de faire appel à une classe supplémentaire.
266:      *
267:      * @param array $parametres tableau des noms des paramètres de la config à verifier.
268:      * @return boolean true si tous les paramétres sont présents sinon false.
269:      */
270:     public static function verifierPresenceParametres(Array $parametres) {
271:         $ok = true;
272:         foreach ($parametres as $param) {
273:             if (is_null(self::get($param))) {
274:                 $classe = get_class();
275:                 $m = "L'utilisation de la classe $classe nécessite de définir '$param' dans un fichier de configuration.";
276:                 trigger_error($m, E_USER_ERROR);
277:                 $ok = false;
278:             }
279:         }
280:         return $ok;
281:     }
282: }
283: ?>