WebSVN – Applications.framework – Diff – /trunk/framework/Config.php


<?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.
 * Si vous avez besoin de modifier dynamiquement des paramètres de configuration, utiliser le @see Registe, il est fait pour ça.
 *
 * @category	PHP 5.2
 * @package	Framework
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
 * @copyright	Copyright (c) 2009, Tela Botanica (accueil@tela-botanica.org)
 * @license	http://www.gnu.org/licenses/gpl.html Licence GNU-GPL-v3
 * @license	http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL-v2
 * @version	$Id: Config.php 489 2014-09-16 13:27:44Z mathias $
 * @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();
 
	private function __construct() {
		// Définition de paramètres avant chargement du config.ini
		self::$parametres = array(
			'fichier_config' => 'config%s.ini',
			'chemin_framework' => dirname(__FILE__).DS
			);
 
		// Chargement du fichier config.ini du Framework
		$existe = self::parserFichierIni(self::$parametres['chemin_framework'].sprintf(self::$parametres['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['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') {
					self::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'])) {
				$_GET['contexte'] = strip_tags($_GET['contexte']);
				self::chargerFichierContexte($_GET['contexte']);
			}
 
			// Chargement du contexte présent dans le POST
			if (isset($_POST['contexte'])) {
				$_POST['contexte'] = strip_tags($_POST['contexte']);
				self::chargerFichierContexte($_POST['contexte']);
			}
		}
	}
 
	/**
	 * Charge le fichier de config correspondant au contexte
	 * @param string $contexte le contexte
	 */
	public static function chargerFichierContexte($contexte) {
		$chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];
		$chemin_config_appli_contextuel .= sprintf(self::$parametres['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);
			$retour = true;
		} else {
			error_log("Fichier de configuration introuvable : $fichier_ini");
		}
		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ée grâce une chaîne 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 (isset($config[$param])) {
				return $config[$param];
			} 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 {
				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]);
			}
			self::fusionner($config);
		}
		return $config;
	}
 
	/**
	 * Dans le cas des chaine de configuration à sous clé (ex.: cle.souscle)
	 * évalue 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]]) && !is_array($config[$pieces[0]])) {
					$m = "Ne peut pas créer de sous-clé pour '{$pieces[0]}' car la clé existe déjà";
					trigger_error($m, E_USER_WARNING);
				} else {
					$config[$pieces[0]][$pieces[1]] = $valeur;
					$config[$pieces[0]] = self::evaluerCle($config[$pieces[0]], $pieces[1], $valeur);
				}
			} else {
				$m = "Clé invalide '$cle'";
				trigger_error($m, E_USER_WARNING);
			}
		} else {
			$config[$cle] = $valeur;
		}
		return $config;
	}
 
	/**
	 * Évalue 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], self::$parametres), $config[$cle]);
			}
		}
	}
 
	/**
	 * Évalue 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);
	}
 
	/**
	 * Accesseur 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);
	}
 
	/**
	 * Vérifie que tous les paramêtres de config nécessaires au fonctionnement d'une classe existe dans les fichiers
	 * de configurations.
	 * L'utilisation de cette méthode depuis la classe Config évite de faire appel à une classe supplémentaire.
	 *
	 * @param array $parametres tableau des noms des paramètres de la config à verifier.
	 * @return boolean true si tous les paramétres sont présents sinon false.
	 */
	public static function verifierPresenceParametres(Array $parametres) {
		$ok = true;
		foreach ($parametres as $param) {
			if (is_null(self::get($param))) {
				$classe = get_class();
				$m = "L'utilisation de la classe $classe nécessite de définir '$param' dans un fichier de configuration.";
				trigger_error($m, E_USER_ERROR);
				$ok = false;
			}
		}
		return $ok;
	}
}
?>

Subversion Repositories Applications.framework

(root)/trunk/framework/Config.php – Rev 447 → 489

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