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.
+ *
  * 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 $instance = null;
+	 */
+	private static $parametres = array();
+	/**
-	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
 		self::parserFichierIni(self::$parametres['fw_chemin'].sprintf(self::$parametres['fw_fichier_config'], ''));
 		// 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')) {
 				chargerFichierContexte('papyrus');
+			}
 			// Via le fichie .ini par défaut de l'appli
 			if (Config::existeValeur('info.contexte', self::$parametres)) {
 				chargerFichierContexte(Config::get('info.contexte'));
+			}
 			// Chargement du contexte présent dans le GET
 			if (isset($_GET['contexte'])) {
 				chargerFichierContexte($_GET['contexte']);
+			}
 			// Chargement du contexte présent dans le POST
 			if (isset($_POST['contexte'])) {
 				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);
+	}
+}
 ?>

Subversion Repositories Applications.framework

(root)/trunk/framework/Config.php – Rev 122 → 129