Subversion Repositories Applications.framework

Compare Revisions

Ignore whitespace Rev 273 → Rev 274

/trunk/framework/I18n.php
33,7 → 33,7
private static $langue = null;
/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
private static $parametres_obligatoires = array('chemin_i18n', 'i18n_url_parametre', 'i18n_langue_defaut', 'fw_debogage');
private static $parametres_obligatoires = array('chemin_i18n', 'i18n_url_parametre', 'i18n_langue_defaut', 'debogage');
private function __construct() {
Config::verifierPresenceParametres(self::$parametres_obligatoires);
227,7 → 227,7
* Ajouter une message d'erreur
*/
private static function ajouterErreur($m, $e = E_USER_WARNING) {
if (Config::get('fw_debogage') === true) {
if (Config::get('debogage') === true) {
trigger_error($m, $e);
}
}
/trunk/framework/Log.php
40,7 → 40,7
private static $ext = '.log';
/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
private static $parametres_obligatoires = array('chemin_logs', 'i18n_timezone', 'fw_taille_max_logs', 'fw_log_debogage');
private static $parametres_obligatoires = array('chemin_logs', 'i18n_timezone', 'log_taille_max', 'log_debogage');
 
/** Initialiser les logs par défaut, sans tenir comptes des paramêtres de config. */
public static function initialiser() {
59,8 → 59,8
Config::verifierPresenceParametres(self::$parametres_obligatoires);
self::$cheminLogs = Config::get('chemin_logs');
self::$timeZone = (Config::get('i18n_timezone') != '') ? Config::get('i18n_timezone') : self::$timeZone;
self::$tailleMax = (Config::get('fw_taille_max_logs') != '') ? Config::get('fw_taille_max_logs') : self::$tailleMax;
self::$logger = (Config::get('fw_log_debogage') != '') ? Config::get('fw_log_debogage') : self::$logger;
self::$tailleMax = (Config::get('log_taille_max') != '') ? Config::get('log_taille_max') : self::$tailleMax;
self::$logger = (Config::get('log_debogage') != '') ? Config::get('log_debogage') : self::$logger;
self::initialiser();
}
 
/trunk/framework/Debug.php
35,7 → 35,7
protected static $mode = null;
/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
private static $parametres_obligatoires = array('fw_debogage', 'fw_debogage_mode');
private static $parametres_obligatoires = array('debogage', 'debogage_mode');
/**
* Accesseur pour le mode
138,8 → 138,8
*/
private static function traiterDebogage($mot_cle, $sortie, $echo) {
Config::verifierPresenceParametres(self::$parametres_obligatoires);
$debogage = Config::get('fw_debogage');
$mode = Config::get('fw_debogage_mode');
$debogage = Config::get('debogage');
$mode = Config::get('debogage_mode');
$mot_cle = self::formaterMotCle($mot_cle);
$sortie = self::traiterSortieSuivantMode($mot_cle, $sortie);
/trunk/framework/Serveur.php
156,7 → 156,7
);
/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
private $parametres_obligatoires = array('fw_debogage', 'fw_debogage_mode', 'serveur.baseURL', 'chemin_modules');
private $parametres_obligatoires = array('debogage', 'debogage_mode', 'serveur.baseURL', 'chemin_modules');
 
/**
* Analyse les données envoyées au serveur, enregistre la méthode HTTP utilisée pour appeler le serveur et parse
165,8 → 165,8
public function __construct() {
Config::verifierPresenceParametres($this->parametres_obligatoires);
self::$debogageActivation = Config::get('fw_debogage');
self::$debogageMode = Config::get('fw_debogage_mode');
self::$debogageActivation = Config::get('debogage');
self::$debogageMode = Config::get('debogage_mode');
 
if (isset($_SERVER['REQUEST_URI']) && isset($_SERVER['REQUEST_METHOD']) && isset($_SERVER['QUERY_STRING'])) {
$this->initialiserMethode();
443,7 → 443,7
* Si nous avec des erreurs d'un type différent d'E_USER_NOTICE (réservé au débogage), elle sont renvoyées sur la sortie
* standard (via echo).
* Si seulement des erreurs de type E_USER_NOTICE, sont présentes, elle sont envoyées en fonction du contenu du paramètre de
* config "fw_debogage_mode" :
* config "debogage_mode" :
* - Debug::MODE_ECHO : les messages sont affichés en utilisant echo au moment où ils sont déclenchés dans le code.
* - Debug::MODE_NOTICE : les message sont stockés par le gestionnaire d'exception sous forme d'erreur de type
* E_USER_NOTICE et sont renvoyés sur la sortie standard à la fin de l'execution du programme (via echo).
/trunk/framework/Framework.php
33,8 → 33,8
 
/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
private static $parametres_obligatoires = array('chemin_controleurs', 'chemin_modeles', 'chemin_bibliotheque',
'fw_url_arg_separateur_entree', 'fw_url_arg_separateur_sortie',
'sortie_encodage', 'appli_encodage');
'url_arg_separateur_entree', 'url_arg_separateur_sortie',
'encodage_sortie', 'encodage_appli');
/**
* Initialise l'environnement nécessaire au Framework : constantes globales, méthodeles autoload, séparateur d'arguments
124,8 → 124,8
* Initialise le format des urls.
*/
private static function initialiserUrl() {
ini_set('arg_separator.input', Config::get('fw_url_arg_separateur_entree'));
ini_set('arg_separator.output', Config::get('fw_url_arg_separateur_sortie'));
ini_set('arg_separator.input', Config::get('furl_arg_separateur_entree'));
ini_set('arg_separator.output', Config::get('url_arg_separateur_sortie'));
}
/**
190,9 → 190,9
* Procédure vérifiant l'encodage des tableaux $_GET et $_POST et les transcodant dans l'encodage de l'application
*/
protected static function verifierEtReencoderTableauRequete() {
if (self::$encodage == false && Config::get('sortie_encodage') != Config::get('appli_encodage')) {
$_POST = self::encoderTableau($_POST, Config::get('appli_encodage'), Config::get('sortie_encodage'));
$_GET = self::encoderTableau($_GET, Config::get('appli_encodage'), Config::get('sortie_encodage'));
if (self::$encodage == false && Config::get('encodage_sortie') != Config::get('encodage_appli')) {
$_POST = self::encoderTableau($_POST, Config::get('encodage_appli'), Config::get('encodage_sortie'));
$_GET = self::encoderTableau($_GET, Config::get('encodage_appli'), Config::get('encodage_sortie'));
// Traitement des magic quotes
self::verifierEtTraiterSlashTableauRequete();
/trunk/framework/Url.php
47,8 → 47,8
private $options = array(
self::OPTION_UTILISER_CROCHETS => true,
self::OPTION_ENCODER_CLES => true,
self::OPTION_SEPARATEUR_ENTREE => 'x&',
self::OPTION_SEPARATEUR_SORTIE => 'x&');
self::OPTION_SEPARATEUR_ENTREE => '&',
self::OPTION_SEPARATEUR_SORTIE => '&');
 
/**
* @var string|bool
86,7 → 86,7
private $fragment = false;
 
/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
private $parametres_obligatoires = array('fw_url_arg_separateur_entree', 'fw_url_arg_separateur_sortie');
private $parametres_obligatoires = array('url_arg_separateur_entree', 'url_arg_separateur_sortie');
/**
* @param string $url une URL relative ou absolue
96,9 → 96,9
Config::verifierPresenceParametres($this->parametres_obligatoires);
$this->setOption(self::OPTION_SEPARATEUR_ENTREE,
Config::get('fw_url_arg_separateur_entree'));
Config::get('url_arg_separateur_entree'));
$this->setOption(self::OPTION_SEPARATEUR_SORTIE,
Config::get('fw_url_arg_separateur_sortie'));
Config::get('url_arg_separateur_sortie'));
if (is_array($options)) {
foreach ($options as $nomOption => $valeur) {
$this->setOption($nomOption);
/trunk/framework/config.defaut.ini
1,3 → 1,4
; Encodage : UTF-8
; Attention : Renommer ce fichier en config.ini
 
; +------------------------------------------------------------------------------------------------------+
11,12 → 12,15
eol = PHP_EOL
 
; +------------------------------------------------------------------------------------------------------+
; Urls
; fw_url_arg_separateur_entree : Le séparateur des arguments d'une url à parser (par défaut, utiliser : "php:ini_get('arg_separator.input')")
; fw_url_arg_separateur_sortie : Le séparateur utilisé pour séparer les arguments d'une URL générée (défaut, utiliser : "php:ini_get('arg_separator.output')")
; URLs
; url_arg_separateur_entree : Le séparateur des arguments d'une url à parser (par défaut, utiliser : "php:ini_get('arg_separator.input')")
; url_arg_separateur_sortie : Le séparateur utilisé pour séparer les arguments d'une URL générée (défaut, utiliser : "php:ini_get('arg_separator.output')")
; url_base : URL de base de l'application. Si vide : fonctionnement Stand-alone
; Peut utiliser un objet Net_URL comme ceci : "php:$mon_objet_net_url->getUrl()"
 
fw_url_arg_separateur_entree = "&"
fw_url_arg_separateur_sortie = "&"
url_arg_separateur_entree = "&"
url_arg_separateur_sortie = "&"
url_base = ""
 
; +------------------------------------------------------------------------------------------------------+
; Débogage
28,28 → 32,32
; - "Autre valeur" : les messages sont formatés puis retournés par la méthode de débogage utilisée.
; fw_debogage_contexte : Indique si oui ou non on veut afficher le contexte de débogage.
; fw_debogage_niveau : Niveau d'erreur à employer pour le code PHP. Voir le manuel de PHP pour les différents niveaux disponibles.
; fw_benchmark_chrono : Indique si oui ou nom on veut afficher le tableau de chronométrage de l'application. (BENCHMARK)
 
fw_debogage = true
fw_debogage_mode = "php:Debug::MODE_ECHO"
fw_debogage_contexte = false
fw_debogage_niveau = 2048
fw_benchmark_chrono = true
 
debogage = true
debogage_mode = "php:Debug::MODE_ECHO"
debogage_contexte = false
debogage_niveau = 2048
 
; +------------------------------------------------------------------------------------------------------+
; Benchmark
; fw_benchmark_chrono : Indique si oui ou nom on veut afficher le tableau de chronométrage de l'application. (BENCHMARK)
benchmark_chrono = true
 
; +------------------------------------------------------------------------------------------------------+
; Log
; fw_taille_max_logs : Indique la taille max d'un fichier log (en octets)
; fw_log_debogage : Indique si oui ou non on veut activer la journalisation des erreurs.
; script_logs : Indique si oui (true) ou non (false) les scripts doivent loguer les messages
; log_debogage : Indique si oui ou non on veut activer la journalisation des erreurs.
; log_script : Indique si oui (true) ou non (false) les scripts doivent loguer les messages
; log_taille_max : Indique la taille max d'un fichier log (en octets)
 
fw_log_debogage = false
fw_taille_max_logs = 1000000
script_logs = true
log_debogage = false
log_script = true
log_taille_max = 1000000
 
; +------------------------------------------------------------------------------------------------------+
; Chemins, dossiers et fichiers
; fw_fichier_config : Nom des fichiers de config recherché. Défini par défaut dans la classe Config
; fw_chemin : Chemin vers le dossier du framework. Défini par défaut dans la classe Config
; fichier_config : Nom des fichiers de config recherché. Défini par défaut dans la classe Config
; chemin_framework : Chemin vers le dossier du framework. Défini par défaut dans la classe Config
; dossier_bibliotheque : Nom du dossier de la bibliotheque de codes de l'application.
; dossier_composants : Nom du dossier des composants graphiques de l'application.
; dossier_configurations : Nom du dossier des controleurs de l'application.
60,8 → 68,8
; dossier_logs : Nom du dossier des logs de l'application.
; dossier_modules : Nom du dossier contenant les modules (sous partie d'une application, scripts ou services web).
 
; fw_fichier_config = "config%s.ini"
; fw_chemin = "php:dirname(__FILE__).DS"
; fichier_config = "config%s.ini"
; chemin_framework = "php:dirname(__FILE__).DS"
 
dossier_bibliotheque = bibliotheque
dossier_composants = composants
117,12 → 125,12
 
; +------------------------------------------------------------------------------------------------------+
; Encodage
; appli_encodage : encodage de l'application, des fichiers php, squelettes de l'application
; sortie_encodage : Encodage des donnés renvoyées au navigateur
; encodage_appli : encodage de l'application, des fichiers php, squelettes de l'application
; encodage_sortie : Encodage des donnés renvoyées au navigateur
; (faire attention à la correspondane avec les .htaccess et les balises meta du html des squelettes)
 
appli_encodage = "UTF-8"
sortie_encodage = "UTF-8"
encodage_appli = "UTF-8"
encodage_sortie = "UTF-8"
 
; +------------------------------------------------------------------------------------------------------+
; I18n
141,13 → 149,6
i18n_systeme_timezone = "php:date_default_timezone_set('{ref:i18n_timezone}');"
 
; +------------------------------------------------------------------------------------------------------+
; URLs
; url_base : URL de base de l'application. Si vide : fonctionnement Stand-alone
; Peut utiliser un objet Net_URL comme ceci : "php:$mon_objet_net_url->getUrl()"
 
url_base = ""
 
; +------------------------------------------------------------------------------------------------------+
; Identifications
; identification : Indiquer ici si l'utilisateur est identifié ou pas.
; Peut utiliser un objet Auth comme ceci : "php:$mon_objet_auth->getAuth()"
/trunk/framework/Script.php
91,7 → 91,7
private static $avancement = array();
/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
private static $parametres_obligatoires = array('chemin_modules', 'script_logs');
private static $parametres_obligatoires = array('chemin_modules', 'log_script');
public function __construct($script_nom, $parametres_cli) {
$this->script_nom = $script_nom;
236,7 → 236,7
$log = $this->formaterMsg($message, $tab_arguments, $niveau);
if ($this->getParametre('v') > ($niveau - 1)) {
echo $log;
if (Config::get('script_logs')) {
if (Config::get('log_script')) {
// TODO : lancer le log
}
}
/trunk/framework/Config.php
27,18 → 27,18
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
'fichier_config' => 'config%s.ini',
'chemin_framework' => dirname(__FILE__).DS
);
 
// Chargement du fichier config.ini du Framework
$existe = self::parserFichierIni(self::$parametres['fw_chemin'].sprintf(self::$parametres['fw_fichier_config'], ''));
$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['fw_fichier_config'], '');
$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
79,7 → 79,7
*/
private static function chargerFichierContexte($contexte) {
$chemin_config_appli_contextuel = self::$parametres['chemin_configurations'];
$chemin_config_appli_contextuel .= sprintf(self::$parametres['fw_fichier_config'], '_'.$contexte);
$chemin_config_appli_contextuel .= sprintf(self::$parametres['ffichier_config'], '_'.$contexte);
self::parserFichierIni($chemin_config_appli_contextuel);
}
 
/trunk/framework/GestionnaireException.php
35,7 → 35,7
private static $mode = null ;
 
/** Tableau des noms des paramètres à définir dans le fichier de config car obligatoirement nécessaire à cette classe.*/
private static $parametres_obligatoires = array('fw_debogage', 'fw_debogage_contexte', 'fw_log_debogage');
private static $parametres_obligatoires = array('debogage', 'debogage_contexte', 'log_debogage');
/** Initialise le Gestionnaire d'exceptions et d'erreur sans tenir comptes des paramêtres de config. */
public static function initialiser() {
52,9 → 52,9
/** Configure le Gestionnaire d'exceptions et d'erreur à partir des paramêtres de config. */
public static function configurer() {
Config::verifierPresenceParametres(self::$parametres_obligatoires);
self::$contexte = Config::get('fw_debogage_contexte');
self::$logger = Config::get('fw_log_debogage');
self::$afficher = Config::get('fw_debogage');
self::$contexte = Config::get('debogage_contexte');
self::$logger = Config::get('log_debogage');
self::$afficher = Config::get('debogage');
}
/**