Subversion Repositories Applications.framework

Rev

Rev 402 | Rev 447 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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