interface/modules/zend_modules/library/Zend/Loader/ClassMapAutoloader.php

   1 <?php
   2 /**
   3  * Zend Framework (http://framework.zend.com/)
   4  *
   5  * @link      http://github.com/zendframework/zf2 for the canonical source repository
   6  * @copyright Copyright (c) 2005-2013 Zend Technologies USA Inc. (http://www.zend.com)
   7  * @license   http://framework.zend.com/license/new-bsd New BSD License
   8  */
   9
  10 namespace Zend\Loader;
  11
  12 use Traversable;
  13
  14 // Grab SplAutoloader interface
  15 require_once __DIR__ . '/SplAutoloader.php';
  16
  17 /**
  18  * Class-map autoloader
  19  *
  20  * Utilizes class-map files to lookup classfile locations.
  21  */
  22 class ClassMapAutoloader implements SplAutoloader
  23 {
  24     /**
  25      * Registry of map files that have already been loaded
  26      * @var array
  27      */
  28     protected $mapsLoaded = array();
  29
  30     /**
  31      * Class name/filename map
  32      * @var array
  33      */
  34     protected $map = array();
  35
  36     /**
  37      * Constructor
  38      *
  39      * Create a new instance, and optionally configure the autoloader.
  40      *
  41      * @param  null|array|Traversable $options
  42      */
  43     public function __construct($options = null)
  44     {
  45         if (null !== $options) {
  46             $this->setOptions($options);
  47         }
  48     }
  49
  50     /**
  51      * Configure the autoloader
  52      *
  53      * Proxies to {@link registerAutoloadMaps()}.
  54      *
  55      * @param  array|Traversable $options
  56      * @return ClassMapAutoloader
  57      */
  58     public function setOptions($options)
  59     {
  60         $this->registerAutoloadMaps($options);
  61         return $this;
  62     }
  63
  64     /**
  65      * Register an autoload map
  66      *
  67      * An autoload map may be either an associative array, or a file returning
  68      * an associative array.
  69      *
  70      * An autoload map should be an associative array containing
  71      * classname/file pairs.
  72      *
  73      * @param  string|array $map
  74      * @throws Exception\InvalidArgumentException
  75      * @return ClassMapAutoloader
  76      */
  77     public function registerAutoloadMap($map)
  78     {
  79         if (is_string($map)) {
  80             $location = $map;
  81             if ($this === ($map = $this->loadMapFromFile($location))) {
  82                 return $this;
  83             }
  84         }
  85
  86         if (!is_array($map)) {
  87             require_once __DIR__ . '/Exception/InvalidArgumentException.php';
  88             throw new Exception\InvalidArgumentException(sprintf(
  89                 'Map file provided does not return a map. Map file: "%s"',
  90                 (isset($location) && is_string($location) ? $location : 'unexpected type: ' . gettype($map))
  91             ));
  92         }
  93
  94         $this->map = array_merge($this->map, $map);
  95
  96         if (isset($location)) {
  97             $this->mapsLoaded[] = $location;
  98         }
  99
 100         return $this;
 101     }
 102
 103     /**
 104      * Register many autoload maps at once
 105      *
 106      * @param  array $locations
 107      * @throws Exception\InvalidArgumentException
 108      * @return ClassMapAutoloader
 109      */
 110     public function registerAutoloadMaps($locations)
 111     {
 112         if (!is_array($locations) && !($locations instanceof Traversable)) {
 113             require_once __DIR__ . '/Exception/InvalidArgumentException.php';
 114             throw new Exception\InvalidArgumentException('Map list must be an array or implement Traversable');
 115         }
 116         foreach ($locations as $location) {
 117             $this->registerAutoloadMap($location);
 118         }
 119         return $this;
 120     }
 121
 122     /**
 123      * Retrieve current autoload map
 124      *
 125      * @return array
 126      */
 127     public function getAutoloadMap()
 128     {
 129         return $this->map;
 130     }
 131
 132     /**
 133      * {@inheritDoc}
 134      */
 135     public function autoload($class)
 136     {
 137         if (isset($this->map[$class])) {
 138             require_once $this->map[$class];
 139
 140             return $class;
 141         }
 142
 143         return false;
 144     }
 145
 146     /**
 147      * Register the autoloader with spl_autoload registry
 148      *
 149      * @return void
 150      */
 151     public function register()
 152     {
 153         spl_autoload_register(array($this, 'autoload'), true, true);
 154     }
 155
 156     /**
 157      * Load a map from a file
 158      *
 159      * If the map has been previously loaded, returns the current instance;
 160      * otherwise, returns whatever was returned by calling include() on the
 161      * location.
 162      *
 163      * @param  string $location
 164      * @return ClassMapAutoloader|mixed
 165      * @throws Exception\InvalidArgumentException for nonexistent locations
 166      */
 167     protected function loadMapFromFile($location)
 168     {
 169         if (!file_exists($location)) {
 170             require_once __DIR__ . '/Exception/InvalidArgumentException.php';
 171             throw new Exception\InvalidArgumentException(sprintf(
 172                 'Map file provided does not exist. Map file: "%s"',
 173                 (is_string($location) ? $location : 'unexpected type: ' . gettype($location))
 174             ));
 175         }
 176
 177         if (!$path = static::realPharPath($location)) {
 178             $path = realpath($location);
 179         }
 180
 181         if (in_array($path, $this->mapsLoaded)) {
 182             // Already loaded this map
 183             return $this;
 184         }
 185
 186         $map = include $path;
 187
 188         return $map;
 189     }
 190
 191     /**
 192      * Resolve the real_path() to a file within a phar.
 193      *
 194      * @see https://bugs.php.net/bug.php?id=52769
 195      * @param  string $path
 196      * @return string
 197      */
 198     public static function realPharPath($path)
 199     {
 200         if (strpos($path, 'phar:///') !== 0) {
 201             return;
 202         }
 203
 204         $parts = explode('/', str_replace(array('/', '\\'), '/', substr($path, 8)));
 205         $parts = array_values(array_filter($parts, function ($p) {
 206             return ($p !== '' && $p !== '.');
 207         }));
 208
 209         array_walk($parts, function ($value, $key) use (&$parts) {
 210             if ($value === '..') {
 211                 unset($parts[$key], $parts[$key-1]);
 212                 $parts = array_values($parts);
 213             }
 214         });
 215
 216         if (file_exists($realPath = 'phar:///' . implode('/', $parts))) {
 217             return $realPath;
 218         }
 219     }
 220 }