Zend FR

<?php

  // ===== Chargement automatique des classes sans devoir faire 
  function __autoload($class) {
      Zend_Loader :: loadClass($class);
  }

  // ===== Includes standards : controller, routeur, configuration, utilitaires
  require_once 'Zend/Loader.php';       // Point d'entrée ZF
  require_once 'Contexte.php';          // Gestion des logs, des paramètres, etc. 
  require_once 'update/index.php';      // Le site est-il en cours de mise à jour 
  require_once 'configuration/configuration.inc.php';   // Lecture des paramètres => seront recopiées en contexte

  // ===== Chargement du comparateur
  Contexte :: loadConfiguration($config);               // Recopie des paramètres

  // ===== On interdit l'interruption de la page à l'utilisateur si cette fonction est disponible
  if ( SET_TIME_LIMIT_ALLOWED ) {
    // set_time_limit(300);
  }

  // ===== Création du/des logger
  /*
  $params = array(
    'host'     => Contexte :: $database['DB_SERVER'],
    'username' => Contexte :: $database['DB_USER'],
    'password' => Contexte :: $database['DB_PASSWORD'],
    'dbname'   => Contexte :: $database['DB_NAME']
  );
  $db_logs =& Zend_Db::factory(Contexte :: $database['DB_TYPE'], $params);
  Zend_Registry :: set('db', $db);
  */

  // $logger =& new Zend_Log_Adapter_Null();
  /*
  $logger =& new Zend_Log_Adapter_File(Contexte :: $paths['logs'] . Contexte :: $logs['main_log_file_name']);
  $logger->setOption('format', Contexte :: $logs['file_log_format']);
  Zend_Log :: registerLogger($logger, Contexte :: $logs['file_logger_tag']);
  */

  /*
  $logAdapter =& new Zend_Log_Adapter_Db($db_logs, Contexte :: $tables['logs']);
  $logAdapter->setOption('fieldMessage', 'LOG_MESSAGE');
  $logAdapter->setOption('fieldLevel', 'LOG_LEVEL');
  Zend_Log :: registerLogger($logAdapter, Contexte :: $logs['db_logger_tag']);
  */

  // ===== Gestion des routes par chargement depuis un fichier de configuration
  $router =& new Zend_Controller_Router_Rewrite();
  $router->addConfig(new Zend_Config_Ini(Contexte :: $paths['configuration'] . 'routes.ini', null), 'routes');

  // ===== Création du controleur Zend
  $controller =& Zend_Controller_Front :: getInstance();
  $controller->setRouter($router);
  $controller->setControllerDirectory(Contexte :: $paths['controllers']);
  $controller->setBaseUrl(ROOT_URL);
  $controller->returnResponse(true);
  // $controller->throwExceptions(true); // A désactiver en production !

  // ===== Création de la vue
  Zend_Loader :: loadClass('Zend_View');
  $view =& new Zend_View;
  $view->setScriptPath(Contexte :: $paths['views']);
  $view->addHelperPath(Contexte :: $paths['helpers']);

  // ===== Enregistrement dans la session courante des objets à propager
  Zend_Registry :: set('view', $view);
  Zend_Registry :: set('router', $router);

  // ===== Démarrage session $_SESSION via Zend_Session
  Zend_Session_Core::start();        

  // ==== Gestion des erreurs non gérées et des exceptions
  /*
  function exception_handler($exception) {
    echo "Exception non attrapée : " , $exception->getMessage(), "<br />";
  }

  function error_handler($severity, $message, $filename, $lineno) {
     echo "Erreur : $severity<br />";
     echo "Message : $message<br />";
     echo "file : $filename, $lineno<br />";
  }

  set_error_handler('error_handler');
  set_exception_handler('exception_handler');
  */

  Contexte :: debug("URI=" . $_SERVER["REQUEST_URI"]);
  Contexte :: loaded(); // Fin du chargement du Contexte

  // ===== Affichage de la page
  $response =& $controller->dispatch();
  if (isset($response) ) {
      if ( $response->isException() ) {
          $exceptions = $response->getException();
          foreach ($exceptions as $exception) {
              Contexte ::error($exception->getMessage());
          }
          if ( DEBUG ) {
              Zend :: dump($exceptions);
          }
      }
      echo $response;
  }
?>

<?php

final class Contexte
{
    // Définition des propriétés sous forme de variables statiques, accessibles depuis Contexte :: $paths, etc.
    static $phpExtension = '.php';
    static $paths = array();
    static $tables = array();
    static $database = array();
    static $logs = array();
    static $render = array();
    static $UTF8_decode = false;
    
    static $logger = null;

    static $errors = array();

    // Gestion des erreurs (pile d'erreurs générées par une page stockées en local pour accès ultérieur)
    public function addError($error) {
        self :: $errors[] = $error;
    }

    public function hasErrors() {
       return ( count(self :: $errors) > 0 );
    }

    // Lecture des paramètres et stockage en local 
    static public function loadConfiguration($config) {

        // On remonte une exception si une variable a été déclarée en configuration mais pas en tant que variable statique ici même
        // TODO voir comment mettre en place un ménisme générique (sans avoir à déclarer les variables ici)
        foreach ($config as $config_name => $config_value) {
            if ( $config_name == 'paths' ) {
                self:: $paths = $config_value;
            } else if ( $config_name == 'tables' ) {
                self:: $tables = $config_value;
            } else if ( $config_name == 'database' ) {
                self:: $database = $config_value;
            } else if ( $config_name == 'phpExtension' ) {
                self:: $phpExtension = $config_value;
            } else if ( $config_name == 'logs' ) {
                self:: $logs = $config_value;
            } else if ( $config_name == 'render' ) {
                self:: $render = $config_value;
            } else if ( $config_name == 'UTF8_decode' ) {
                self :: $UTF8_decode = $config_value;
            } else {
                throw new Exception("Erreur lecture d'une propriété non déclarée : '$config_name'");
            }
        }

        // ===== Gestion des includes : ajout du répertoire des modèles pour loadClass facilité
        $current_path = self:: $paths['models'].PATH_SEPARATOR.get_include_path();
        if ( ! ereg('.' . PATH_SEPARATOR, $current_path) ) {
          $current_path = '.'.PATH_SEPARATOR . $current_path;
        }
        set_include_path($current_path);
    }
    
    // Méthode retournant le logger courant
    static public function getLogger() {
        if ( self :: $logger == null ) {
            self :: $logger = new Zend_Log();
        }
        return self :: $logger;
    }

    // Decodage UTF8 si besoin est
    static public function utf8_decode($s) {
        if ( self :: $UTF8_decode === true ) {
            $s = utf8_decode($s);
        }
        return $s;
    }

    // Encodage UTF8 si besoin est
    static public function utf8_encode($s) {
        if ( self :: $UTF8_decode === true ) {
            $s = utf8_encode($s);
        }
        return $s;
    }

    // Chargement d'une interface
    static public function loadInterface($interface, $dirs = null) {

        // autodiscover the path from the class name
        $path = str_replace('_', DIRECTORY_SEPARATOR, $interface);
        if ($dirs === null && $path != $interface) {
            // use the autodiscovered path
            $dirs = dirname($path);
            $file = basename($path) . '.php';
        } else {
            $file = $interface . '.php';
        }

        Zend_Loader :: loadFile($file, $dirs, true);
    }

    // Chargement d'une librairie externe
    static public function loadLibrary($library, $dirs = null) {
      $file = $library . '.inc';
      Zend_Loader :: loadFile($file . self:: $phpExtension, 'lib/');
    }

    // Méthode à appeler lorsque la classe Comparateur a fini d'être chargée
    static function loaded() {
        self :: debug('Path de recherche = "' . get_include_path() . '"');
    }

    // Méthode de debug - à réécrire avec getLogger()
    static function debug($s) {
        /*
        if ( DEBUG && Contexte :: $logs['log_to_file'] ) {
            $params = array('date' => date(self:: $logs['log_date_format']), 'mylevel' => 'D');
            self :: getLogger()->debug($s, Zend_Log::LEVEL_DEBUG, $params, self :: $logs['file_logger_tag']);
        }
        if ( DEBUG && Contexte :: $logs['log_to_db'] ) {
            self :: getLogger()->debug($s, Zend_Log::LEVEL_DEBUG, self :: $logs['db_logger_tag']);
        }
        */
    }

    static function info($s) {
        /*
        if ( Contexte :: $logs['log_to_file'] ) {
            $params = array('date' => date(self:: $logs['log_date_format']), 'mylevel' => 'I');
            self :: getLogger()->debug($s, Zend_Log::LEVEL_INFO, $params, self:: $logs['file_logger_tag']);
        }
        if ( Contexte :: $logs['log_to_db'] ) {
            Zend_Log :: log($s, Zend_Log::LEVEL_INFO, self:: $logs['db_logger_tag']);
        }
        */
    }

    static function warn($s) {
        /*
        if ( Contexte :: $logs['log_to_file'] ) {
            $params = array('date' => date(self:: $logs['log_date_format']), 'mylevel' => 'W');
            Zend_Log :: log($s, Zend_Log::LEVEL_WARNING, $params, self:: $logs['file_logger_tag']);
        }
        if ( Contexte :: $logs['log_to_db'] ) {
            Zend_Log :: log($s, Zend_Log::LEVEL_WARNING, self:: $logs['db_logger_tag']);
        }
        */
    }

    static function error($s) {
        /*
        if ( Contexte :: $logs['log_to_file'] ) {
            $params = array('date' => date(self:: $logs['log_date_format']), 'mylevel' => 'E');
            Zend_Log :: log($s, Zend_Log::LEVEL_ERROR, $params, self:: $logs['file_logger_tag']);
        }
        if ( Contexte :: $logs['log_to_db'] ) {
            Zend_Log :: log($s, Zend_Log::LEVEL_ERROR, self:: $logs['db_logger_tag']);
        }
        */
    }
}