Subversion Repositories Applications.framework

Compare Revisions

Ignore whitespace Rev 97 → Rev 98

/trunk/framework/Config.php
3,38 → 3,43
* 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
*
*
* 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/
* @license GPL-v3 et CECILL-v2
* @version SVN: <svn_id>
* @link /doc/framework/
*/
 
class Config {
 
private static $instance = null;
private static $parametres = array();
 
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'], ''));
$chemin_config_appli_contextuel = self::$parametres['dossier_configurations'];
 
// 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 (defined('PAP_VERSION')) {
$chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];
$chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '_papyrus');
} else {
$chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '');
self::parserFichierIni($chemin_config_appli_contextuel);
}
self::parserFichierIni($chemin_config_appli_contextuel);
}
 
private static function parserFichierIni($fichier_ini) {
41,91 → 46,116
$retour = false;
if (file_exists($fichier_ini)) {
$ini = parse_ini_file($fichier_ini, true);
$ini = self::evaluerPhp($ini);
$ini = self::analyserTableauIni($ini);
self::fusionner($ini);
$retour = true;
}
return $retour;
}
 
private static function fusionner(array $ini) {
self::$parametres = array_merge(self::$parametres, $ini);
}
 
public static function charger($fichier_ini) {
self::verifierCreationInstance();
return self::parserFichierIni($fichier_ini);
}
public static function get($param) {
$retour = '';
 
public static function get($param = null) {
$retour = null;
self::verifierCreationInstance();
if (isset(self::$parametres[$param])) {
$retour = self::$parametres[$param];
if ($param === null) {
$retour = self::$parametres;
} else {
$retour = self::getValeur($param, self::$parametres);
}
return $retour;
}
public static function getSection($section, $param = null) {
$retour = '';
self::verifierCreationInstance();
if (isset(self::$parametres[$section])) {
if (!is_null($param)) {
if (isset(self::$parametres[$section][$param])) {
$retour = self::$parametres[$section][$param];
}
} else {
$retour = self::$parametres[$section];
}
}
return $retour;
 
private static function getValeur($param, $config) {
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;
}
 
public static function existe($param) {
$retour = false;
self::verifierCreationInstance();
if (isset(self::$parametres[$param])) {
if (self::getValeur($param, self::$parametres) !== null) {
$retour = true;
}
return $retour;
}
public static function existeSection($section, $param = null) {
$retour = false;
self::verifierCreationInstance();
if (isset(self::$parametres[$section])) {
if (!is_null($param)) {
if (isset(self::$parametres[$section][$param])) {
$retour = true;
}
} else {
$retour = true;
}
}
return $retour;
}
 
private static function verifierCreationInstance() {
if (empty(self::$instance)) {
self::$instance = new Config();
self::$instance = new Config();
}
}
private static function evaluerPhp($tableau_a_analyser) {
if (is_array($tableau_a_analyser)) {
foreach ($tableau_a_analyser as $cle => $valeur) {
if (is_array($valeur)) {
$tableau_a_analyser[$cle] = self::evaluerPhp($valeur);
} else {
if (preg_match('/^php:(.+)$/', $valeur, $correspondances)) {
eval('$tableau_a_analyser["'.$cle.'"] = '.$correspondances[1].';');
} else {
$tableau_a_analyser[$cle] = $valeur;
}
}
}
}
return $tableau_a_analyser;
 
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;
}
 
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;
}
 
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], $config[$ref[1]], $config[$cle]);
}
}
}
 
private static function evaluerPhp(&$config, $cle) {
if (preg_match('/^php:(.+)$/', $config[$cle], $correspondances)) {
eval('$config["'.$cle.'"] = '.$correspondances[1].';');
}
}
}
?>
/trunk/framework/GestionnaireException.php
87,9 → 87,19
public function getExceptions() {
foreach ($this->exceptions as $e) {
switch($this->mode) {
case 'cli' :
$retour .= $e->getMessage()."\n";
$retour .= 'Fichier : '.$e->getFile()."\n";
$retour .= 'Ligne : '.$e->getLine()."\n";
$retour .= 'Message : '.$e->getMessage()."\n";
$retour .= 'Fichier : '.$e->getFile()."\n";
$retour .= 'Ligne : '.$e->getLine()."\n";
if ($this->getContexte()) {
$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
}
break;
default:
$retour .= '<pre class="debogage">'."\n";
$retour .= htmlentities($e->getMessage())."\n";
$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";
101,19 → 111,7
$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";
$retour .= '</pre>'."\n";
}
break;
default:
$retour .= $e->getMessage()."\n";
$retour .= 'Fichier : '.$e->getFile()."\n";
$retour .= 'Ligne : '.$e->getLine()."\n";
$retour .= 'Message : '.$e->getMessage()."\n";
$retour .= 'Fichier : '.$e->getFile()."\n";
$retour .= 'Ligne : '.$e->getLine()."\n";
if ($this->getContexte()) {
$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
}
}
}
}
return $retour;
}
/trunk/framework/Controleur.php
53,9 → 53,9
}
$this->registre = Registre::getInstance();
$this->registre->set('base_chemin_modele', Config::get('dossier_modeles'));
$this->registre->set('base_chemin_squelette', Config::get('dossier_squelettes'));
$this->registre->set('base_chemin_controleur', Config::get('dossier_controleurs'));
$this->registre->set('base_chemin_modele', Config::get('chemin_modeles'));
$this->registre->set('base_chemin_squelette', Config::get('chemin_squelettes'));
$this->registre->set('base_chemin_controleur', Config::get('chemin_controleurs'));
$this->registre->set('base_url_application', new Url(Config::get('url_base')));
$this->_gestionnaire_exception = GestionnaireException::getInstance();
$this->_gestionnaire_erreur = GestionnaireErreur::getInstance();
/trunk/framework/autoload.inc.php
1,21 → 1,20
<?php
/**
* Fichier contenant la fonction __autoload
* Fichier contenant la fonction de chargement automatique de classes, il doit toujours rester à la racine
* du framework car il initialise le chemin de l'application en se basant sur son propre emplacement.
*
* Fichier contenant la fonction de chargement automatique
* de classes, il doit toujours rester à la racine
* du framework car il initialise le chemin de
* l'application en se basant sur son propre emplacement.
* PHP Version 5.1.2
*
* PHP Version 5
*
* @category Fichier_De_Fonctions
* @package Framework
* @author aurelien <aurelien@tela-botanica.org>
* @copyright 2009 Tela-Botanica
* @license http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
* @version SVN: <svn_id>
* @link /doc/framework/
// Auteur principal :
* @author Aurelien PERONNET <aurelien@tela-botanica.org>
// Autres auteurs :
* @author Jean-Pascal MILCENT <jpm@tela-botanica.org>
* @license GPL v3 <http://www.gnu.org/licenses/gpl.txt>
* @license CECILL v2 <http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt>
* @version $$Id$$
* @copyright 1999-2009 Tela Botanica (accueil@tela-botanica.org)
*/
 
// Redéfinition de la constante DIRECTORY_SEPARATOR
27,6 → 26,7
define('PS', PATH_SEPARATOR);
}
 
// Autoload pour le Framework
function autoloadFw($nom_classe_fw) {
$fichier_a_inclure = dirname(__FILE__).DS.$nom_classe_fw.'.php';
if (file_exists($fichier_a_inclure)) {
36,10 → 36,11
}
spl_autoload_register('autoloadFw');
 
// Autoload par défaut pour l'application
function autoloadAppliDefaut($nom_classe) {
$dossiers_classes = array( Config::get('dossier_controleurs'),
Config::get('dossier_modeles'),
Config::get('dossier_bibliotheque'));
$dossiers_classes = array( Config::get('chemin_controleurs'),
Config::get('chemin_modeles'),
Config::get('chemin_bibliotheque'));
foreach ($dossiers_classes as $chemin) {
$fichier_a_tester = $chemin.$nom_classe.'.php';
51,8 → 52,8
}
spl_autoload_register('autoloadAppliDefaut');
 
// Autoload définit par l'application
if (function_exists('__autoload')) {
spl_autoload_register('__autoload');
}
 
?>
/trunk/framework/Application.php
18,17 → 18,7
private static $info = null;
private static $chemin = null;
 
/**
* Le tableau des informations sur l'application possède les clés suivantes :
* - nom : nom de l'application
* - abr : abréviation de l'application
* - encodage : encodage de l'application (ISO-8859-15, UTF-8...)
*
* @param string $chemin_fichier_principal
* @param array $info tableau fournissant des informations sur l'application
* @return void
*/
public static function set($chemin_fichier_principal, $info = null) {
public static function setChemin($chemin_fichier_principal) {
if (self::$chemin === null) {
if (!file_exists($chemin_fichier_principal)) {
trigger_error("Le fichier indiqué n'existe pas. Utilisez __FILE__ dans la méthode set().", E_USER_ERROR);
35,9 → 25,8
} else {
self::$chemin = dirname($chemin_fichier_principal).DS;
}
self::$info = $info;
} else {
trigger_error("L'application a déjà été enregistrée auprès du Framework", E_USER_WARNING);
trigger_error("Le chemin de l'application a déjà été enregistré auprès du Framework", E_USER_WARNING);
}
}
 
45,6 → 34,22
return self::$chemin;
}
 
/** Le tableau des informations sur l'application possède les clés suivantes :
* - nom : nom de l'application
* - abr : abréviation de l'application
* - encodage : encodage de l'application (ISO-8859-15, UTF-8...)
*
* @param array $info tableau fournissant des informations sur l'application
* @return void
*/
public static function setInfo($info) {
if (self::$info === null) {
self::$info = $info;
} else {
trigger_error("Le informations de l'application ont déjà été enregistrées auprès du Framework", E_USER_WARNING);
}
}
 
public static function getInfo($cle = null) {
if ($cle !== null) {
if (isset(self::$info[$cle])) {
/trunk/framework/Registre.php
18,9 → 18,8
* Constructeur par défaut, privé, car on accède à la classe par le getInstance
*/
private function __construct() {
$registre = $this;
}
 
/**
* Fonction qui renvoie l'instance de classe en assurant son unicité, c'est l'unique méthode qui doit être
* utilisé pour récupérer l'objet Registre
32,11 → 31,11
self::$registre = new Registre;
return self::$registre;
}
 
/**
* Ajoute un objet au tableau selon un intitulé donné
* @param string l'intitulé sous lequel l'objet sera conservé
* @param mixed l'objet à conserver
* @param mixed l'objet à conserver
*/
public function set($intitule, $objet) {
if (is_array($objet) && isset($this->stockage[$intitule])) {
58,7 → 57,7
}
return null;
}
 
/**
* Détruit l'objet associé à l'intitulé, n'a pas d'effet si il n'y a pas d'objet associé
*/
67,11 → 66,11
unset($this->stockage[$intitule]);
}
}
 
/**
* Teste si un objet est présent sous un intitulé donné
* @return boolean true si un objet associé à cet intitulé est présent, false sinon
*/
* @return boolean true si un objet associé à cet intitulé est présent, false sinon
*/
public function existe($intitule) {
if(isset($this->stockage[$intitule])){
return true;
/trunk/framework/config.defaut.ini
1,4 → 1,13
; +------------------------------------------------------------------------------------------------------+
; Général
; Séparateur de dossier
ds = DIRECTORY_SEPARATOR
; Séparateur de chemin
ps = PATH_SEPARATOR
; Fin de ligne de fichier
eol = PHP_EOL
 
; +------------------------------------------------------------------------------------------------------+
; Débogage
; Indique si oui ou non on veut afficher le débogage.
fw_debogage = true
15,25 → 24,43
; +------------------------------------------------------------------------------------------------------+
; Chemins et fichiers
; Nom des fichiers de config recherché. Défini par défaut dans la classe Config
; fw_fichier_config = "config.ini"
; fw_fichier_config = "config%s.ini"
; Chemin vers le dossier du framework. Défini par défaut dans la classe Config
; fw_chemin = "php:dirname(__FILE__).DS"
; Chemin vers le dossier de l'appli. Défini par défaut dans la classe Config
; chemin_appli = "php:dirname($_SERVER['SCRIPT_FILENAME']).DS"
 
; Nom du dossier de la bibliotheque de codes de l'application.
dossier_bibliotheque = bibliotheque
; Nom du dossier des composants graphiques de l'application.
dossier_composants = composants
; Nom du dossier des controleurs de l'application.
dossier_configurations = configurations
; Nom du dossier des controleurs de l'application.
dossier_controleurs = controleurs
; Nom du dossier des traductions de l'application.
dossier_i18n = i18n
; Nom du dossier des modèles de l'application.
dossier_modeles = modeles
; Nom du dossier des squelettes de l'application.
dossier_squelettes = squelettes
 
; Chemin vers le dossier de l'appli.
chemin_appli = "php:Application::getChemin()"
; Chemin vers le dossier de la bibliotheque de codes de l'application.
chemin_bibliotheque = "{ref:chemin_appli}{ref:dossier_bibliotheque}{ref:ds}"
; Chemin vers le dossier des composants graphiques de l'application.
chemin_composants = "{ref:chemin_appli}{ref:dossier_composants}{ref:ds}"
; Chemin vers le dossier des controleurs de l'application.
dossier_controleurs = "php:dirname($_SERVER['SCRIPT_FILENAME']).DS.'controleurs'.DS"
chemin_configurations = "{ref:chemin_appli}{ref:dossier_configurations}{ref:ds}"
; Chemin vers le dossier des controleurs de l'application.
chemin_controleurs = "{ref:chemin_appli}{ref:dossier_controleurs}{ref:ds}"
; Chemin vers le dossier des traductions de l'application.
chemin_i18n = "{ref:chemin_appli}{ref:dossier_i18n}{ref:ds}"
; Chemin vers le dossier des modèles de l'application.
dossier_modeles = "php:dirname($_SERVER['SCRIPT_FILENAME']).DS.'modeles'.DS"
chemin_modeles = "{ref:chemin_appli}{ref:dossier_modeles}{ref:ds}"
; Chemin vers le dossier des squelettes de l'application.
dossier_squelettes = "php:dirname($_SERVER['SCRIPT_FILENAME']).DS.'squelettes'.DS"
chemin_squelettes = "{ref:chemin_appli}{ref:dossier_squelettes}{ref:ds}"
 
; +------------------------------------------------------------------------------------------------------+
; URLs
; URL de base de l'application, si elle est laissée vide, l'application fonctionnera en Stand-alone
url_base = ""
 
; +------------------------------------------------------------------------------------------------------+
; Paramétrage de la base de données.
; Protocole de la base de données.
bdd_protocole = mysql
44,4 → 71,16
; Mot de passse de l'utilisateur de la base de données.
bdd_mot_de_passe = ""
; Nom de la base de données principale.
bdd_nom = ""
bdd_nom = ""
 
; +------------------------------------------------------------------------------------------------------+
; URLs
; URL de base de l'application, si elle est laissée vide, l'application fonctionnera en Stand-alone
; Peut utiliser une objet Net_URL comme ceci : "php:$mon_objet_net_url->getUrl()"
url_base = ""
 
; +------------------------------------------------------------------------------------------------------+
; Identifications
; Indiquer ici si l'utilisateur est identifié ou pas.
; Peut utiliser un objet Auth comme ceci : "php:$mon_objet_auth->getAuth()"
identification = true