1. sfSimpleAutoload.class.php
  2. /**
 * sfSimpleAutoload class.
 *
 * This class is a singleton as PHP seems to be unable to register 2 autoloaders that are instances
 * of the same class (why?).
 *
 * @package    symfony
 * @subpackage autoload
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfSimpleAutoload.class.php 23205 2009-10-20 13:20:17Z Kris.Wallsmith $
 */
  3. class sfSimpleAutoload
  4. {
  5.   static protected
  6.     $registered = false,
  7.     $instance   = null;
  9.   protected
  10.     $cacheFile    = null,
  11.     $cacheLoaded  = false,
  12.     $cacheChanged = false,
  13.     $dirs         = array(),
  14.     $files        = array(),
  15.     $classes      = array(),
  16.     $overriden    = array();
  18.   protected function __construct($cacheFile = null)
  19.   {
  20.     if (null !== $cacheFile)
  21.     {
  22.       $this->cacheFile = $cacheFile;
  23.     }
  25.     $this->loadCache();
  26.   }
  28.   /**
  29.    * Retrieves the singleton instance of this class.
  30.    *
  31.    * @param  string $cacheFile  The file path to save the cache
  32.    *
  33.    * @return sfSimpleAutoload   A sfSimpleAutoload implementation instance.
  34.    */
  35.   static public function getInstance($cacheFile = null)
  36.   {
  37.     if (!isset(self::$instance))
  38.     {
  39.       self::$instance = new sfSimpleAutoload($cacheFile);
  40.     }
  42.     return self::$instance;
  43.   }
  45.   /**
  46.    * Register sfSimpleAutoload in spl autoloader.
  47.    *
  48.    * @return void
  49.    */
  50.   static public function register()
  51.   {
  52.     if (self::$registered)
  53.     {
  54.       return;
  55.     }
  57.     ini_set('unserialize_callback_func', 'spl_autoload_call');
  58.     if (false === spl_autoload_register(array(self::getInstance(), 'autoload')))
  59.     {
  60.       throw new sfException(sprintf('Unable to register %s::autoload as an autoloading method.', get_class(self::getInstance())));
  61.     }
  63.     if (self::getInstance()->cacheFile)
  64.     {
  65.       register_shutdown_function(array(self::getInstance(), 'saveCache'));
  66.     }
  68.     self::$registered = true;
  69.   }
  71.   /**
  72.    * Unregister sfSimpleAutoload from spl autoloader.
  73.    *
  74.    * @return void
  75.    */
  76.   static public function unregister()
  77.   {
  78.     spl_autoload_unregister(array(self::getInstance(), 'autoload'));
  79.     self::$registered = false;
  80.   }
  82.   /**
  83.    * Handles autoloading of classes.
  84.    *
  85.    * @param  string $class A class name.
  86.    *
  87.    * @return boolean Returns true if the class has been loaded
  88.    */
  89.   public function autoload($class)
  90.   {
  91.     $class = strtolower($class);
  93.     // class already exists
  94.     if (class_exists($class, false) || interface_exists($class, false))
  95.     {
  96.       return true;
  97.     }
  99.     // we have a class path, let's include it
  100.     if (isset($this->classes[$class]))
  101.     {
  102.       try
  103.       {
  104.         require $this->classes[$class];
  105.       }
  106.       catch (sfException $e)
  107.       {
  108.         $e->printStackTrace();
  109.       }
  110.       catch (Exception $e)
  111.       {
  112.         sfException::createFromException($e)->printStackTrace();
  113.       }
  115.       return true;
  116.     }
  118.     return false;
  119.   }
  121.   /**
  122.    * Loads the cache.
  123.    */
  124.   public function loadCache()
  125.   {
  126.     if (!$this->cacheFile || !is_readable($this->cacheFile))
  127.     {
  128.       return;
  129.     }
  131.     list($this->classes, $this->dirs, $this->files) = unserialize(file_get_contents($this->cacheFile));
  133.     $this->cacheLoaded = true;
  134.     $this->cacheChanged = false;
  135.   }
  137.   /**
  138.    * Saves the cache.
  139.    */
  140.   public function saveCache()
  141.   {
  142.     if ($this->cacheChanged)
  143.     {
  144.       if (is_writable(dirname($this->cacheFile)))
  145.       {
  146.         file_put_contents($this->cacheFile, serialize(array($this->classes, $this->dirs, $this->files)));
  147.       }
  149.       $this->cacheChanged = false;
  150.     }
  151.   }
  153.   /**
  154.    * Reloads cache.
  155.    */
  156.   public function reload()
  157.   {
  158.     $this->classes = array();
  159.     $this->cacheLoaded = false;
  161.     foreach ($this->dirs as $dir)
  162.     {
  163.       $this->addDirectory($dir);
  164.     }
  166.     foreach ($this->files as $file)
  167.     {
  168.       $this->addFile($file);
  169.     }
  171.     foreach ($this->overriden as $class => $path)
  172.     {
  173.       $this->classes[$class] = $path;
  174.     }
  176.     $this->cacheLoaded = true;
  177.     $this->cacheChanged = true;
  178.   }
  180.   /**
  181.    * Removes the cache.
  182.    */
  183.   public function removeCache()
  184.   {
  185.     @unlink($this->cacheFile);
  186.   }
  188.   /**
  189.    * Adds a directory to the autoloading system if not yet present and give it the highest possible precedence.
  190.    *
  191.    * @param string $dir The directory to look for classes
  192.    * @param string $ext The extension to look for
  193.    */
  194.   public function addDirectory($dir, $ext = '.php')
  195.   {
  196.     $finder = sfFinder::type('file')->follow_link()->name('*'.$ext);
  198.     if ($dirs = glob($dir))
  199.     {
  200.       foreach ($dirs as $dir)
  201.       {
  202.         if (false !== $key = array_search($dir, $this->dirs))
  203.         {
  204.           unset($this->dirs[$key]);
  205.           $this->dirs[] = $dir;
  207.           if ($this->cacheLoaded)
  208.           {
  209.             continue;
  210.           }
  211.         }
  212.         else
  213.         {
  214.           $this->dirs[] = $dir;
  215.         }
  217.         $this->cacheChanged = true;
  218.         $this->addFiles($finder->in($dir), false);
  219.       }
  220.     }
  221.   }
  223.   /**
  224.    * Adds files to the autoloading system.
  225.    *
  226.    * @param array   $files    An array of files
  227.    * @param Boolean $register Whether to register those files as single entities (used when reloading)
  228.    */
  229.   public function addFiles(array $files, $register = true)
  230.   {
  231.     foreach ($files as $file)
  232.     {
  233.       $this->addFile($file, $register);
  234.     }
  235.   }
  237.   /**
  238.    * Adds a file to the autoloading system.
  239.    *
  240.    * @param string  $file     A file path
  241.    * @param Boolean $register Whether to register those files as single entities (used when reloading)
  242.    */
  243.   public function addFile($file, $register = true)
  244.   {
  245.     if (!is_file($file))
  246.     {
  247.       return;
  248.     }
  250.     if (in_array($file, $this->files))
  251.     {
  252.       if ($this->cacheLoaded)
  253.       {
  254.         return;
  255.       }
  256.     }
  257.     else
  258.     {
  259.       if ($register)
  260.       {
  261.         $this->files[] = $file;
  262.       }
  263.     }
  265.     if ($register)
  266.     {
  267.       $this->cacheChanged = true;
  268.     }
  270.     preg_match_all('~^\s*(?:abstract\s+|final\s+)?(?:class|interface)\s+(\w+)~mi', file_get_contents($file), $classes);
  271.     foreach ($classes[1] as $class)
  272.     {
  273.       $this->classes[strtolower($class)] = $file;
  274.     }
  275.   }
  277.   /**
  278.    * Sets the path for a particular class.
  279.    *
  280.    * @param string $class A PHP class name
  281.    * @param string $path  An absolute path
  282.    */
  283.   public function setClassPath($class, $path)
  284.   {
  285.     $class = strtolower($class);
  287.     $this->overriden[$class] = $path;
  289.     $this->classes[$class] = $path;
  290.   }
  292.   /**
  293.    * Returns the path where a particular class can be found.
  294.    *
  295.    * @param string $class A PHP class name
  296.    *
  297.    * @return string|null An absolute path
  298.    */
  299.   public function getClassPath($class)
  300.   {
  301.     $class = strtolower($class);
  303.     return isset($this->classes[$class]) ? $this->classes[$class] : null;
  304.   }
  306.   /**
  307.    * Loads configuration from the supplied files.
  308.    *
  309.    * @param array $files An array of autoload.yml files
  310.    * 
  311.    * @see sfAutoloadConfigHandler
  312.    */
  313.   public function loadConfiguration(array $files)
  314.   {
  315.     $config = new sfAutoloadConfigHandler();
  316.     foreach ($config->evaluate($files) as $class => $file)
  317.     {
  318.       $this->setClassPath($class, $file);
  319.     }
  320.   }
  321. }
Debug toolbar