[Divagation] Les courants d'air

<?php

/**
 * CLASSLOADER
 * @version(R001)
 * @date(2012-01-25)
 * @author(TRON)
 * @see(DirectoriesAutoloaderException, ExtensionFilterIteratorDecorator)
 */
class DirectoriesAutoloader {

   private static    $_instance;
   private       $_cachePath;
   private       $_canRegenerate;
   private       $_classes;
   private       $_directories;

   private function __construct () {
      $this->_canRegenerate = true;
      $this->_classes = array();
      $this->_directories = array();
   }

   public static function getInstance($pCachePath){
      echo "Création du ClassLoader.<br>"
         ."Cache : [".$pCachePath."]<br>";
      if ( self::$_instance == NULL ) {
         self::$_instance = new DirectoriesAutoloader();
         self::$_instance->setCachePath($pCachePath);
      }
      return self::$_instance;
   }

   public function setCachePath($cachePath){
      if ( !is_writable ($cachePath) ) {
         throw new DirectoriesAutoloaderException('Ecriture impossible sur ['.$cachePath.']');
      }
      $this->cachePath = $cachePath;
   }

   /**
    * Méthode de chargement d'une classe.
    */
   public function autoload($pClassName) {
      if ( $this->_loadClass($pClassName) ) {
         return true;
      }
 
      if ( $this->_canRegenerate ){
         $this->_canRegenerate = false;
         $this->_includesAll();
         $this->_saveInCache();
         return $this->autoload($pClassName);
      }

      return false;
   }

   private function _includesAll() {
      foreach ( $this->_directories as $directory=>$recursive ) {
         $directories = new AppendIterator ();
          if ( $recursive ) {
            $directories->append(new RecursiveIteratorIterator(new RecursiveDirectoryIterator($directory)));
         } else {
            $directories->append(new DirectoryIterator($directory));
         }
 
         $files = new ExtensionFilterIteratorDecorator($directories);
         $files->setExtension('.php');
 
         foreach ( $files as $fileName ) {
            $classes = $this->_extractClasses((string)$fileName);
            foreach ( $classes as $className=>$fileName ) {
               $this->_classes[strtolower($className)] = $fileName;
            }
         }
      }
   }

   public function toString() {
      $str = "<u>Classes chargées :</u><br>";
      foreach ( $this->_classes as $key => $value ) {
         $str .= "[".$key."]<br>";
      }
      return $str;
   }
 
   private function _extractClasses($pFileName){
      $toReturn = array();
      $tokens = token_get_all(file_get_contents ($pFileName, false));
      $tokens = array_filter($tokens, 'is_array');
 
      $classHunt = false;
      foreach ( $tokens as $token ) {
         if ( $token[0] === T_INTERFACE || $token[0] === T_CLASS ) {
            $classHunt = true;
            continue;
         }
         if ( $classHunt && $token[0] === T_STRING ) {
            $toReturn[$token[1]] = $pFileName;
            $classHunt = false;
         }
      }
 
      return $toReturn;
   }

   private function _saveInCache() {
      echo "Sauvegarde en cache<br>";
      $toSave = '<?php $classes = '.var_export($this->_classes, true).'; ?>';
      file_put_contents($this->_cachePath.'directoriesautoloader.cache.php', htmlentities($toSave));
   }
 
   private function _loadClass($pClassName){
      $className = strtolower($pClassName);
      echo count($this->_classes);
      if ( count($this->_classes) === 0 ) {
         if ( is_readable($this->_cachePath.'directoriesautoloader.cache.php') ) {
            require($this->_cachePath.'directoriesautoloader.cache.php');
            $this->_classes = $className;
         }
      }
      if ( isset($this->_classes) && isset($this->_classes[$className]) ) {
         require_once($this->_classes[$className]);
         return true;
      }
      return false;
   }
 
  /**
    * Méthode d'ajout d'un répertoire au ClassLoader.
    */
   public function addDirectory($pDirectory, $pRecursive = true){
      if ( !is_readable($pDirectory) ) {
         throw new DirectoriesAutoloaderException('Lecture impossible ['.$pDirectory.']');
      }
      $this->_directories[$pDirectory] = $pRecursive ? true : false;
      return $this;
   }
}

Sauvegarde en cache
25Classes chargées :
[controller]
[error_controller]
[technicalexception]
[error_model]
[model]
[genbox]
[logappenderenum]
[logger]
[loggerfactory]
[loglevelenum]
[connexion]
[connexionabstractbuilder]
[connexionbuilder]
[connexionfactory]
[connexiontypeenum]
[expression]
[test]
[testrunner]
[arrayutils]
[extensionfilteriteratordecorator]
[directoriesautoloaderexception]
[directoriesautoloader]
[filepropertiemanager]
[fileutils]
[stringutils]