1 <?php

     2 /**

     3  * Zend Framework

     4  *

     5  * LICENSE

     6  *

     7  * This source file is subject to the new BSD license that is bundled

     8  * with this package in the file LICENSE.txt.

     9  * It is also available through the world-wide-web at this URL:

    10  * http://framework.zend.com/license/new-bsd

    11  * If you did not receive a copy of the license and are unable to

    12  * obtain it through the world-wide-web, please send an email

    13  * to license@zend.com so we can send you a copy immediately.

    14  *

    15  * @category   Zend

    16  * @package    Zend_Loader

    17  * @subpackage Autoloader

    18  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

    19  * @version    $Id: Autoloader.php 23161 2010-10-19 16:08:36Z matthew $

    20  * @license    http://framework.zend.com/license/new-bsd     New BSD License

    21  */

    22 

    23 /** Zend_Loader */

    24 require_once 'Zend/Loader.php';

    25 

    26 /**

    27  * Autoloader stack and namespace autoloader

    28  *

    29  * @uses       Zend_Loader_Autoloader

    30  * @package    Zend_Loader

    31  * @subpackage Autoloader

    32  * @copyright  Copyright (c) 2005-2010 Zend Technologies USA Inc. (http://www.zend.com)

    33  * @license    http://framework.zend.com/license/new-bsd     New BSD License

    34  */

    35 class Zend_Loader_Autoloader

    36 {

    37     /**

    38      * @var Zend_Loader_Autoloader Singleton instance

    39      */

    40     protected static $_instance;

    41 

    42     /**

    43      * @var array Concrete autoloader callback implementations

    44      */

    45     protected $_autoloaders = array();

    46 

    47     /**

    48      * @var array Default autoloader callback

    49      */

    50     protected $_defaultAutoloader = array('Zend_Loader', 'loadClass');

    51 

    52     /**

    53      * @var bool Whether or not to act as a fallback autoloader

    54      */

    55     protected $_fallbackAutoloader = false;

    56 

    57     /**

    58      * @var array Callback for internal autoloader implementation

    59      */

    60     protected $_internalAutoloader;

    61 

    62     /**

    63      * @var array Supported namespaces 'Zend' and 'ZendX' by default.

    64      */

    65     protected $_namespaces = array(

    66         'Zend_'  => true,

    67         'ZendX_' => true,

    68     );

    69 

    70     /**

    71      * @var array Namespace-specific autoloaders

    72      */

    73     protected $_namespaceAutoloaders = array();

    74 

    75     /**

    76      * @var bool Whether or not to suppress file not found warnings

    77      */

    78     protected $_suppressNotFoundWarnings = false;

    79 

    80     /**

    81      * @var null|string

    82      */

    83     protected $_zfPath;

    84 

    85     /**

    86      * Retrieve singleton instance

    87      *

    88      * @return Zend_Loader_Autoloader

    89      */

    90     public static function getInstance()

    91     {

    92         if (null === self::$_instance) {

    93             self::$_instance = new self();

    94         }

    95         return self::$_instance;

    96     }

    97 

    98     /**

    99      * Reset the singleton instance

   100      *

   101      * @return void

   102      */

   103     public static function resetInstance()

   104     {

   105         self::$_instance = null;

   106     }

   107 

   108     /**

   109      * Autoload a class

   110      *

   111      * @param  string $class

   112      * @return bool

   113      */

   114     public static function autoload($class)

   115     {

   116         $self = self::getInstance();

   117 

   118         foreach ($self->getClassAutoloaders($class) as $autoloader) {

   119             if ($autoloader instanceof Zend_Loader_Autoloader_Interface) {

   120                 if ($autoloader->autoload($class)) {

   121                     return true;

   122                 }

   123             } elseif (is_array($autoloader)) {

   124                 if (call_user_func($autoloader, $class)) {

   125                     return true;

   126                 }

   127             } elseif (is_string($autoloader) || is_callable($autoloader)) {

   128                 if ($autoloader($class)) {

   129                     return true;

   130                 }

   131             }

   132         }

   133 

   134         return false;

   135     }

   136 

   137     /**

   138      * Set the default autoloader implementation

   139      *

   140      * @param  string|array $callback PHP callback

   141      * @return void

   142      */

   143     public function setDefaultAutoloader($callback)

   144     {

   145         if (!is_callable($callback)) {

   146             throw new Zend_Loader_Exception('Invalid callback specified for default autoloader');

   147         }

   148 

   149         $this->_defaultAutoloader = $callback;

   150         return $this;

   151     }

   152 

   153     /**

   154      * Retrieve the default autoloader callback

   155      *

   156      * @return string|array PHP Callback

   157      */

   158     public function getDefaultAutoloader()

   159     {

   160         return $this->_defaultAutoloader;

   161     }

   162 

   163     /**

   164      * Set several autoloader callbacks at once

   165      *

   166      * @param  array $autoloaders Array of PHP callbacks (or Zend_Loader_Autoloader_Interface implementations) to act as autoloaders

   167      * @return Zend_Loader_Autoloader

   168      */

   169     public function setAutoloaders(array $autoloaders)

   170     {

   171         $this->_autoloaders = $autoloaders;

   172         return $this;

   173     }

   174 

   175     /**

   176      * Get attached autoloader implementations

   177      *

   178      * @return array

   179      */

   180     public function getAutoloaders()

   181     {

   182         return $this->_autoloaders;

   183     }

   184 

   185     /**

   186      * Return all autoloaders for a given namespace

   187      *

   188      * @param  string $namespace

   189      * @return array

   190      */

   191     public function getNamespaceAutoloaders($namespace)

   192     {

   193         $namespace = (string) $namespace;

   194         if (!array_key_exists($namespace, $this->_namespaceAutoloaders)) {

   195             return array();

   196         }

   197         return $this->_namespaceAutoloaders[$namespace];

   198     }

   199 

   200     /**

   201      * Register a namespace to autoload

   202      *

   203      * @param  string|array $namespace

   204      * @return Zend_Loader_Autoloader

   205      */

   206     public function registerNamespace($namespace)

   207     {

   208         if (is_string($namespace)) {

   209             $namespace = (array) $namespace;

   210         } elseif (!is_array($namespace)) {

   211             throw new Zend_Loader_Exception('Invalid namespace provided');

   212         }

   213 

   214         foreach ($namespace as $ns) {

   215             if (!isset($this->_namespaces[$ns])) {

   216                 $this->_namespaces[$ns] = true;

   217             }

   218         }

   219         return $this;

   220     }

   221 

   222     /**

   223      * Unload a registered autoload namespace

   224      *

   225      * @param  string|array $namespace

   226      * @return Zend_Loader_Autoloader

   227      */

   228     public function unregisterNamespace($namespace)

   229     {

   230         if (is_string($namespace)) {

   231             $namespace = (array) $namespace;

   232         } elseif (!is_array($namespace)) {

   233             throw new Zend_Loader_Exception('Invalid namespace provided');

   234         }

   235 

   236         foreach ($namespace as $ns) {

   237             if (isset($this->_namespaces[$ns])) {

   238                 unset($this->_namespaces[$ns]);

   239             }

   240         }

   241         return $this;

   242     }

   243 

   244     /**

   245      * Get a list of registered autoload namespaces

   246      *

   247      * @return array

   248      */

   249     public function getRegisteredNamespaces()

   250     {

   251         return array_keys($this->_namespaces);

   252     }

   253 

   254     public function setZfPath($spec, $version = 'latest')

   255     {

   256         $path = $spec;

   257         if (is_array($spec)) {

   258             if (!isset($spec['path'])) {

   259                 throw new Zend_Loader_Exception('No path specified for ZF');

   260             }

   261             $path = $spec['path'];

   262             if (isset($spec['version'])) {

   263                 $version = $spec['version'];

   264             }

   265         }

   266 

   267         $this->_zfPath = $this->_getVersionPath($path, $version);

   268         set_include_path(implode(PATH_SEPARATOR, array(

   269             $this->_zfPath,

   270             get_include_path(),

   271         )));

   272         return $this;

   273     }

   274 

   275     public function getZfPath()

   276     {

   277         return $this->_zfPath;

   278     }

   279 

   280     /**

   281      * Get or set the value of the "suppress not found warnings" flag

   282      *

   283      * @param  null|bool $flag

   284      * @return bool|Zend_Loader_Autoloader Returns boolean if no argument is passed, object instance otherwise

   285      */

   286     public function suppressNotFoundWarnings($flag = null)

   287     {

   288         if (null === $flag) {

   289             return $this->_suppressNotFoundWarnings;

   290         }

   291         $this->_suppressNotFoundWarnings = (bool) $flag;

   292         return $this;

   293     }

   294 

   295     /**

   296      * Indicate whether or not this autoloader should be a fallback autoloader

   297      *

   298      * @param  bool $flag

   299      * @return Zend_Loader_Autoloader

   300      */

   301     public function setFallbackAutoloader($flag)

   302     {

   303         $this->_fallbackAutoloader = (bool) $flag;

   304         return $this;

   305     }

   306 

   307     /**

   308      * Is this instance acting as a fallback autoloader?

   309      *

   310      * @return bool

   311      */

   312     public function isFallbackAutoloader()

   313     {

   314         return $this->_fallbackAutoloader;

   315     }

   316 

   317     /**

   318      * Get autoloaders to use when matching class

   319      *

   320      * Determines if the class matches a registered namespace, and, if so,

   321      * returns only the autoloaders for that namespace. Otherwise, it returns

   322      * all non-namespaced autoloaders.

   323      *

   324      * @param  string $class

   325      * @return array Array of autoloaders to use

   326      */

   327     public function getClassAutoloaders($class)

   328     {

   329         $namespace   = false;

   330         $autoloaders = array();

   331 

   332         // Add concrete namespaced autoloaders

   333         foreach (array_keys($this->_namespaceAutoloaders) as $ns) {

   334             if ('' == $ns) {

   335                 continue;

   336             }

   337             if (0 === strpos($class, $ns)) {

   338                 $namespace   = $ns;

   339                 $autoloaders = $autoloaders + $this->getNamespaceAutoloaders($ns);

   340                 break;

   341             }

   342         }

   343 

   344         // Add internal namespaced autoloader

   345         foreach ($this->getRegisteredNamespaces() as $ns) {

   346             if (0 === strpos($class, $ns)) {

   347                 $namespace     = $ns;

   348                 $autoloaders[] = $this->_internalAutoloader;

   349                 break;

   350             }

   351         }

   352 

   353         // Add non-namespaced autoloaders

   354         $autoloaders = $autoloaders + $this->getNamespaceAutoloaders('');

   355 

   356         // Add fallback autoloader

   357         if (!$namespace && $this->isFallbackAutoloader()) {

   358             $autoloaders[] = $this->_internalAutoloader;

   359         }

   360 

   361         return $autoloaders;

   362     }

   363 

   364     /**

   365      * Add an autoloader to the beginning of the stack

   366      *

   367      * @param  object|array|string $callback PHP callback or Zend_Loader_Autoloader_Interface implementation

   368      * @param  string|array $namespace Specific namespace(s) under which to register callback

   369      * @return Zend_Loader_Autoloader

   370      */

   371     public function unshiftAutoloader($callback, $namespace = '')

   372     {

   373         $autoloaders = $this->getAutoloaders();

   374         array_unshift($autoloaders, $callback);

   375         $this->setAutoloaders($autoloaders);

   376 

   377         $namespace = (array) $namespace;

   378         foreach ($namespace as $ns) {

   379             $autoloaders = $this->getNamespaceAutoloaders($ns);

   380             array_unshift($autoloaders, $callback);

   381             $this->_setNamespaceAutoloaders($autoloaders, $ns);

   382         }

   383 

   384         return $this;

   385     }

   386 

   387     /**

   388      * Append an autoloader to the autoloader stack

   389      *

   390      * @param  object|array|string $callback PHP callback or Zend_Loader_Autoloader_Interface implementation

   391      * @param  string|array $namespace Specific namespace(s) under which to register callback

   392      * @return Zend_Loader_Autoloader

   393      */

   394     public function pushAutoloader($callback, $namespace = '')

   395     {

   396         $autoloaders = $this->getAutoloaders();

   397         array_push($autoloaders, $callback);

   398         $this->setAutoloaders($autoloaders);

   399 

   400         $namespace = (array) $namespace;

   401         foreach ($namespace as $ns) {

   402             $autoloaders = $this->getNamespaceAutoloaders($ns);

   403             array_push($autoloaders, $callback);

   404             $this->_setNamespaceAutoloaders($autoloaders, $ns);

   405         }

   406 

   407         return $this;

   408     }

   409 

   410     /**

   411      * Remove an autoloader from the autoloader stack

   412      *

   413      * @param  object|array|string $callback PHP callback or Zend_Loader_Autoloader_Interface implementation

   414      * @param  null|string|array $namespace Specific namespace(s) from which to remove autoloader

   415      * @return Zend_Loader_Autoloader

   416      */

   417     public function removeAutoloader($callback, $namespace = null)

   418     {

   419         if (null === $namespace) {

   420             $autoloaders = $this->getAutoloaders();

   421             if (false !== ($index = array_search($callback, $autoloaders, true))) {

   422                 unset($autoloaders[$index]);

   423                 $this->setAutoloaders($autoloaders);

   424             }

   425 

   426             foreach ($this->_namespaceAutoloaders as $ns => $autoloaders) {

   427                 if (false !== ($index = array_search($callback, $autoloaders, true))) {

   428                     unset($autoloaders[$index]);

   429                     $this->_setNamespaceAutoloaders($autoloaders, $ns);

   430                 }

   431             }

   432         } else {

   433             $namespace = (array) $namespace;

   434             foreach ($namespace as $ns) {

   435                 $autoloaders = $this->getNamespaceAutoloaders($ns);

   436                 if (false !== ($index = array_search($callback, $autoloaders, true))) {

   437                     unset($autoloaders[$index]);

   438                     $this->_setNamespaceAutoloaders($autoloaders, $ns);

   439                 }

   440             }

   441         }

   442 

   443         return $this;

   444     }

   445 

   446     /**

   447      * Constructor

   448      *

   449      * Registers instance with spl_autoload stack

   450      *

   451      * @return void

   452      */

   453     protected function __construct()

   454     {

   455         spl_autoload_register(array(__CLASS__, 'autoload'));

   456         $this->_internalAutoloader = array($this, '_autoload');

   457     }

   458 

   459     /**

   460      * Internal autoloader implementation

   461      *

   462      * @param  string $class

   463      * @return bool

   464      */

   465     protected function _autoload($class)

   466     {

   467         $callback = $this->getDefaultAutoloader();

   468         try {

   469             if ($this->suppressNotFoundWarnings()) {

   470                 @call_user_func($callback, $class);

   471             } else {

   472                 call_user_func($callback, $class);

   473             }

   474             return $class;

   475         } catch (Zend_Exception $e) {

   476             return false;

   477         }

   478     }

   479 

   480     /**

   481      * Set autoloaders for a specific namespace

   482      *

   483      * @param  array $autoloaders

   484      * @param  string $namespace

   485      * @return Zend_Loader_Autoloader

   486      */

   487     protected function _setNamespaceAutoloaders(array $autoloaders, $namespace = '')

   488     {

   489         $namespace = (string) $namespace;

   490         $this->_namespaceAutoloaders[$namespace] = $autoloaders;

   491         return $this;

   492     }

   493 

   494     /**

   495      * Retrieve the filesystem path for the requested ZF version

   496      *

   497      * @param  string $path

   498      * @param  string $version

   499      * @return void

   500      */

   501     protected function _getVersionPath($path, $version)

   502     {

   503         $type = $this->_getVersionType($version);

   504 

   505         if ($type == 'latest') {

   506             $version = 'latest';

   507         }

   508 

   509         $availableVersions = $this->_getAvailableVersions($path, $version);

   510         if (empty($availableVersions)) {

   511             throw new Zend_Loader_Exception('No valid ZF installations discovered');

   512         }

   513 

   514         $matchedVersion = array_pop($availableVersions);

   515         return $matchedVersion;

   516     }

   517 

   518     /**

   519      * Retrieve the ZF version type

   520      *

   521      * @param  string $version

   522      * @return string "latest", "major", "minor", or "specific"

   523      * @throws Zend_Loader_Exception if version string contains too many dots

   524      */

   525     protected function _getVersionType($version)

   526     {

   527         if (strtolower($version) == 'latest') {

   528             return 'latest';

   529         }

   530 

   531         $parts = explode('.', $version);

   532         $count = count($parts);

   533         if (1 == $count) {

   534             return 'major';

   535         }

   536         if (2 == $count) {

   537             return 'minor';

   538         }

   539         if (3 < $count) {

   540             throw new Zend_Loader_Exception('Invalid version string provided');

   541         }

   542         return 'specific';

   543     }

   544 

   545     /**

   546      * Get available versions for the version type requested

   547      *

   548      * @param  string $path

   549      * @param  string $version

   550      * @return array

   551      */

   552     protected function _getAvailableVersions($path, $version)

   553     {

   554         if (!is_dir($path)) {

   555             throw new Zend_Loader_Exception('Invalid ZF path provided');

   556         }

   557 

   558         $path       = rtrim($path, '/');

   559         $path       = rtrim($path, '\\');

   560         $versionLen = strlen($version);

   561         $versions   = array();

   562         $dirs       = glob("$path/*", GLOB_ONLYDIR);

   563         foreach ((array) $dirs as $dir) {

   564             $dirName = substr($dir, strlen($path) + 1);

   565             if (!preg_match('/^(?:ZendFramework-)?(\d+\.\d+\.\d+((a|b|pl|pr|p|rc)\d+)?)(?:-minimal)?$/i', $dirName, $matches)) {

   566                 continue;

   567             }

   568 

   569             $matchedVersion = $matches[1];

   570 

   571             if (('latest' == $version)

   572                 || ((strlen($matchedVersion) >= $versionLen)

   573                     && (0 === strpos($matchedVersion, $version)))

   574             ) {

   575                 $versions[$matchedVersion] = $dir . '/library';

   576             }

   577         }

   578 

   579         uksort($versions, 'version_compare');

   580         return $versions;

   581     }

   582 }