|
0
|
1 <?php
|
|
|
2
|
|
|
3 /*
|
|
|
4 * This file is part of Composer.
|
|
|
5 *
|
|
|
6 * (c) Nils Adermann <naderman@naderman.de>
|
|
|
7 * Jordi Boggiano <j.boggiano@seld.be>
|
|
|
8 *
|
|
|
9 * For the full copyright and license information, please view the LICENSE
|
|
|
10 * file that was distributed with this source code.
|
|
|
11 */
|
|
|
12
|
|
|
13 namespace Composer\Autoload;
|
|
|
14
|
|
|
15 /**
|
|
|
16 * ClassLoader implements a PSR-0, PSR-4 and classmap class loader.
|
|
|
17 *
|
|
|
18 * $loader = new \Composer\Autoload\ClassLoader();
|
|
|
19 *
|
|
|
20 * // register classes with namespaces
|
|
|
21 * $loader->add('Symfony\Component', __DIR__.'/component');
|
|
|
22 * $loader->add('Symfony', __DIR__.'/framework');
|
|
|
23 *
|
|
|
24 * // activate the autoloader
|
|
|
25 * $loader->register();
|
|
|
26 *
|
|
|
27 * // to enable searching the include path (eg. for PEAR packages)
|
|
|
28 * $loader->setUseIncludePath(true);
|
|
|
29 *
|
|
|
30 * In this example, if you try to use a class in the Symfony\Component
|
|
|
31 * namespace or one of its children (Symfony\Component\Console for instance),
|
|
|
32 * the autoloader will first look for the class under the component/
|
|
|
33 * directory, and it will then fallback to the framework/ directory if not
|
|
|
34 * found before giving up.
|
|
|
35 *
|
|
|
36 * This class is loosely based on the Symfony UniversalClassLoader.
|
|
|
37 *
|
|
|
38 * @author Fabien Potencier <fabien@symfony.com>
|
|
|
39 * @author Jordi Boggiano <j.boggiano@seld.be>
|
|
|
40 * @see http://www.php-fig.org/psr/psr-0/
|
|
|
41 * @see http://www.php-fig.org/psr/psr-4/
|
|
|
42 */
|
|
|
43 class ClassLoader
|
|
|
44 {
|
|
|
45 // PSR-4
|
|
|
46 private $prefixLengthsPsr4 = array();
|
|
|
47 private $prefixDirsPsr4 = array();
|
|
|
48 private $fallbackDirsPsr4 = array();
|
|
|
49
|
|
|
50 // PSR-0
|
|
|
51 private $prefixesPsr0 = array();
|
|
|
52 private $fallbackDirsPsr0 = array();
|
|
|
53
|
|
|
54 private $useIncludePath = false;
|
|
|
55 private $classMap = array();
|
|
|
56 private $classMapAuthoritative = false;
|
|
|
57 private $missingClasses = array();
|
|
|
58 private $apcuPrefix;
|
|
|
59
|
|
|
60 public function getPrefixes()
|
|
|
61 {
|
|
|
62 if (!empty($this->prefixesPsr0)) {
|
|
|
63 return call_user_func_array('array_merge', $this->prefixesPsr0);
|
|
|
64 }
|
|
|
65
|
|
|
66 return array();
|
|
|
67 }
|
|
|
68
|
|
|
69 public function getPrefixesPsr4()
|
|
|
70 {
|
|
|
71 return $this->prefixDirsPsr4;
|
|
|
72 }
|
|
|
73
|
|
|
74 public function getFallbackDirs()
|
|
|
75 {
|
|
|
76 return $this->fallbackDirsPsr0;
|
|
|
77 }
|
|
|
78
|
|
|
79 public function getFallbackDirsPsr4()
|
|
|
80 {
|
|
|
81 return $this->fallbackDirsPsr4;
|
|
|
82 }
|
|
|
83
|
|
|
84 public function getClassMap()
|
|
|
85 {
|
|
|
86 return $this->classMap;
|
|
|
87 }
|
|
|
88
|
|
|
89 /**
|
|
|
90 * @param array $classMap Class to filename map
|
|
|
91 */
|
|
|
92 public function addClassMap(array $classMap)
|
|
|
93 {
|
|
|
94 if ($this->classMap) {
|
|
|
95 $this->classMap = array_merge($this->classMap, $classMap);
|
|
|
96 } else {
|
|
|
97 $this->classMap = $classMap;
|
|
|
98 }
|
|
|
99 }
|
|
|
100
|
|
|
101 /**
|
|
|
102 * Registers a set of PSR-0 directories for a given prefix, either
|
|
|
103 * appending or prepending to the ones previously set for this prefix.
|
|
|
104 *
|
|
|
105 * @param string $prefix The prefix
|
|
|
106 * @param array|string $paths The PSR-0 root directories
|
|
|
107 * @param bool $prepend Whether to prepend the directories
|
|
|
108 */
|
|
|
109 public function add($prefix, $paths, $prepend = false)
|
|
|
110 {
|
|
|
111 if (!$prefix) {
|
|
|
112 if ($prepend) {
|
|
|
113 $this->fallbackDirsPsr0 = array_merge(
|
|
|
114 (array) $paths,
|
|
|
115 $this->fallbackDirsPsr0
|
|
|
116 );
|
|
|
117 } else {
|
|
|
118 $this->fallbackDirsPsr0 = array_merge(
|
|
|
119 $this->fallbackDirsPsr0,
|
|
|
120 (array) $paths
|
|
|
121 );
|
|
|
122 }
|
|
|
123
|
|
|
124 return;
|
|
|
125 }
|
|
|
126
|
|
|
127 $first = $prefix[0];
|
|
|
128 if (!isset($this->prefixesPsr0[$first][$prefix])) {
|
|
|
129 $this->prefixesPsr0[$first][$prefix] = (array) $paths;
|
|
|
130
|
|
|
131 return;
|
|
|
132 }
|
|
|
133 if ($prepend) {
|
|
|
134 $this->prefixesPsr0[$first][$prefix] = array_merge(
|
|
|
135 (array) $paths,
|
|
|
136 $this->prefixesPsr0[$first][$prefix]
|
|
|
137 );
|
|
|
138 } else {
|
|
|
139 $this->prefixesPsr0[$first][$prefix] = array_merge(
|
|
|
140 $this->prefixesPsr0[$first][$prefix],
|
|
|
141 (array) $paths
|
|
|
142 );
|
|
|
143 }
|
|
|
144 }
|
|
|
145
|
|
|
146 /**
|
|
|
147 * Registers a set of PSR-4 directories for a given namespace, either
|
|
|
148 * appending or prepending to the ones previously set for this namespace.
|
|
|
149 *
|
|
|
150 * @param string $prefix The prefix/namespace, with trailing '\\'
|
|
|
151 * @param array|string $paths The PSR-4 base directories
|
|
|
152 * @param bool $prepend Whether to prepend the directories
|
|
|
153 *
|
|
|
154 * @throws \InvalidArgumentException
|
|
|
155 */
|
|
|
156 public function addPsr4($prefix, $paths, $prepend = false)
|
|
|
157 {
|
|
|
158 if (!$prefix) {
|
|
|
159 // Register directories for the root namespace.
|
|
|
160 if ($prepend) {
|
|
|
161 $this->fallbackDirsPsr4 = array_merge(
|
|
|
162 (array) $paths,
|
|
|
163 $this->fallbackDirsPsr4
|
|
|
164 );
|
|
|
165 } else {
|
|
|
166 $this->fallbackDirsPsr4 = array_merge(
|
|
|
167 $this->fallbackDirsPsr4,
|
|
|
168 (array) $paths
|
|
|
169 );
|
|
|
170 }
|
|
|
171 } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
|
|
|
172 // Register directories for a new namespace.
|
|
|
173 $length = strlen($prefix);
|
|
|
174 if ('\\' !== $prefix[$length - 1]) {
|
|
|
175 throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
|
|
|
176 }
|
|
|
177 $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
|
|
|
178 $this->prefixDirsPsr4[$prefix] = (array) $paths;
|
|
|
179 } elseif ($prepend) {
|
|
|
180 // Prepend directories for an already registered namespace.
|
|
|
181 $this->prefixDirsPsr4[$prefix] = array_merge(
|
|
|
182 (array) $paths,
|
|
|
183 $this->prefixDirsPsr4[$prefix]
|
|
|
184 );
|
|
|
185 } else {
|
|
|
186 // Append directories for an already registered namespace.
|
|
|
187 $this->prefixDirsPsr4[$prefix] = array_merge(
|
|
|
188 $this->prefixDirsPsr4[$prefix],
|
|
|
189 (array) $paths
|
|
|
190 );
|
|
|
191 }
|
|
|
192 }
|
|
|
193
|
|
|
194 /**
|
|
|
195 * Registers a set of PSR-0 directories for a given prefix,
|
|
|
196 * replacing any others previously set for this prefix.
|
|
|
197 *
|
|
|
198 * @param string $prefix The prefix
|
|
|
199 * @param array|string $paths The PSR-0 base directories
|
|
|
200 */
|
|
|
201 public function set($prefix, $paths)
|
|
|
202 {
|
|
|
203 if (!$prefix) {
|
|
|
204 $this->fallbackDirsPsr0 = (array) $paths;
|
|
|
205 } else {
|
|
|
206 $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
|
|
|
207 }
|
|
|
208 }
|
|
|
209
|
|
|
210 /**
|
|
|
211 * Registers a set of PSR-4 directories for a given namespace,
|
|
|
212 * replacing any others previously set for this namespace.
|
|
|
213 *
|
|
|
214 * @param string $prefix The prefix/namespace, with trailing '\\'
|
|
|
215 * @param array|string $paths The PSR-4 base directories
|
|
|
216 *
|
|
|
217 * @throws \InvalidArgumentException
|
|
|
218 */
|
|
|
219 public function setPsr4($prefix, $paths)
|
|
|
220 {
|
|
|
221 if (!$prefix) {
|
|
|
222 $this->fallbackDirsPsr4 = (array) $paths;
|
|
|
223 } else {
|
|
|
224 $length = strlen($prefix);
|
|
|
225 if ('\\' !== $prefix[$length - 1]) {
|
|
|
226 throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
|
|
|
227 }
|
|
|
228 $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
|
|
|
229 $this->prefixDirsPsr4[$prefix] = (array) $paths;
|
|
|
230 }
|
|
|
231 }
|
|
|
232
|
|
|
233 /**
|
|
|
234 * Turns on searching the include path for class files.
|
|
|
235 *
|
|
|
236 * @param bool $useIncludePath
|
|
|
237 */
|
|
|
238 public function setUseIncludePath($useIncludePath)
|
|
|
239 {
|
|
|
240 $this->useIncludePath = $useIncludePath;
|
|
|
241 }
|
|
|
242
|
|
|
243 /**
|
|
|
244 * Can be used to check if the autoloader uses the include path to check
|
|
|
245 * for classes.
|
|
|
246 *
|
|
|
247 * @return bool
|
|
|
248 */
|
|
|
249 public function getUseIncludePath()
|
|
|
250 {
|
|
|
251 return $this->useIncludePath;
|
|
|
252 }
|
|
|
253
|
|
|
254 /**
|
|
|
255 * Turns off searching the prefix and fallback directories for classes
|
|
|
256 * that have not been registered with the class map.
|
|
|
257 *
|
|
|
258 * @param bool $classMapAuthoritative
|
|
|
259 */
|
|
|
260 public function setClassMapAuthoritative($classMapAuthoritative)
|
|
|
261 {
|
|
|
262 $this->classMapAuthoritative = $classMapAuthoritative;
|
|
|
263 }
|
|
|
264
|
|
|
265 /**
|
|
|
266 * Should class lookup fail if not found in the current class map?
|
|
|
267 *
|
|
|
268 * @return bool
|
|
|
269 */
|
|
|
270 public function isClassMapAuthoritative()
|
|
|
271 {
|
|
|
272 return $this->classMapAuthoritative;
|
|
|
273 }
|
|
|
274
|
|
|
275 /**
|
|
|
276 * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
|
|
|
277 *
|
|
|
278 * @param string|null $apcuPrefix
|
|
|
279 */
|
|
|
280 public function setApcuPrefix($apcuPrefix)
|
|
|
281 {
|
|
|
282 $this->apcuPrefix = function_exists('apcu_fetch') && ini_get('apc.enabled') ? $apcuPrefix : null;
|
|
|
283 }
|
|
|
284
|
|
|
285 /**
|
|
|
286 * The APCu prefix in use, or null if APCu caching is not enabled.
|
|
|
287 *
|
|
|
288 * @return string|null
|
|
|
289 */
|
|
|
290 public function getApcuPrefix()
|
|
|
291 {
|
|
|
292 return $this->apcuPrefix;
|
|
|
293 }
|
|
|
294
|
|
|
295 /**
|
|
|
296 * Registers this instance as an autoloader.
|
|
|
297 *
|
|
|
298 * @param bool $prepend Whether to prepend the autoloader or not
|
|
|
299 */
|
|
|
300 public function register($prepend = false)
|
|
|
301 {
|
|
|
302 spl_autoload_register(array($this, 'loadClass'), true, $prepend);
|
|
|
303 }
|
|
|
304
|
|
|
305 /**
|
|
|
306 * Unregisters this instance as an autoloader.
|
|
|
307 */
|
|
|
308 public function unregister()
|
|
|
309 {
|
|
|
310 spl_autoload_unregister(array($this, 'loadClass'));
|
|
|
311 }
|
|
|
312
|
|
|
313 /**
|
|
|
314 * Loads the given class or interface.
|
|
|
315 *
|
|
|
316 * @param string $class The name of the class
|
|
|
317 * @return bool|null True if loaded, null otherwise
|
|
|
318 */
|
|
|
319 public function loadClass($class)
|
|
|
320 {
|
|
|
321 if ($file = $this->findFile($class)) {
|
|
|
322 includeFile($file);
|
|
|
323
|
|
|
324 return true;
|
|
|
325 }
|
|
|
326 }
|
|
|
327
|
|
|
328 /**
|
|
|
329 * Finds the path to the file where the class is defined.
|
|
|
330 *
|
|
|
331 * @param string $class The name of the class
|
|
|
332 *
|
|
|
333 * @return string|false The path if found, false otherwise
|
|
|
334 */
|
|
|
335 public function findFile($class)
|
|
|
336 {
|
|
|
337 // class map lookup
|
|
|
338 if (isset($this->classMap[$class])) {
|
|
|
339 return $this->classMap[$class];
|
|
|
340 }
|
|
|
341 if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
|
|
|
342 return false;
|
|
|
343 }
|
|
|
344 if (null !== $this->apcuPrefix) {
|
|
|
345 $file = apcu_fetch($this->apcuPrefix.$class, $hit);
|
|
|
346 if ($hit) {
|
|
|
347 return $file;
|
|
|
348 }
|
|
|
349 }
|
|
|
350
|
|
|
351 $file = $this->findFileWithExtension($class, '.php');
|
|
|
352
|
|
|
353 // Search for Hack files if we are running on HHVM
|
|
|
354 if (false === $file && defined('HHVM_VERSION')) {
|
|
|
355 $file = $this->findFileWithExtension($class, '.hh');
|
|
|
356 }
|
|
|
357
|
|
|
358 if (null !== $this->apcuPrefix) {
|
|
|
359 apcu_add($this->apcuPrefix.$class, $file);
|
|
|
360 }
|
|
|
361
|
|
|
362 if (false === $file) {
|
|
|
363 // Remember that this class does not exist.
|
|
|
364 $this->missingClasses[$class] = true;
|
|
|
365 }
|
|
|
366
|
|
|
367 return $file;
|
|
|
368 }
|
|
|
369
|
|
|
370 private function findFileWithExtension($class, $ext)
|
|
|
371 {
|
|
|
372 // PSR-4 lookup
|
|
|
373 $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
|
|
|
374
|
|
|
375 $first = $class[0];
|
|
|
376 if (isset($this->prefixLengthsPsr4[$first])) {
|
|
|
377 $subPath = $class;
|
|
|
378 while (false !== $lastPos = strrpos($subPath, '\\')) {
|
|
|
379 $subPath = substr($subPath, 0, $lastPos);
|
|
|
380 $search = $subPath.'\\';
|
|
|
381 if (isset($this->prefixDirsPsr4[$search])) {
|
|
|
382 foreach ($this->prefixDirsPsr4[$search] as $dir) {
|
|
|
383 $length = $this->prefixLengthsPsr4[$first][$search];
|
|
|
384 if (file_exists($file = $dir . DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $length))) {
|
|
|
385 return $file;
|
|
|
386 }
|
|
|
387 }
|
|
|
388 }
|
|
|
389 }
|
|
|
390 }
|
|
|
391
|
|
|
392 // PSR-4 fallback dirs
|
|
|
393 foreach ($this->fallbackDirsPsr4 as $dir) {
|
|
|
394 if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
|
|
|
395 return $file;
|
|
|
396 }
|
|
|
397 }
|
|
|
398
|
|
|
399 // PSR-0 lookup
|
|
|
400 if (false !== $pos = strrpos($class, '\\')) {
|
|
|
401 // namespaced class name
|
|
|
402 $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
|
|
|
403 . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
|
|
|
404 } else {
|
|
|
405 // PEAR-like class name
|
|
|
406 $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
|
|
|
407 }
|
|
|
408
|
|
|
409 if (isset($this->prefixesPsr0[$first])) {
|
|
|
410 foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
|
|
|
411 if (0 === strpos($class, $prefix)) {
|
|
|
412 foreach ($dirs as $dir) {
|
|
|
413 if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
|
|
|
414 return $file;
|
|
|
415 }
|
|
|
416 }
|
|
|
417 }
|
|
|
418 }
|
|
|
419 }
|
|
|
420
|
|
|
421 // PSR-0 fallback dirs
|
|
|
422 foreach ($this->fallbackDirsPsr0 as $dir) {
|
|
|
423 if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
|
|
|
424 return $file;
|
|
|
425 }
|
|
|
426 }
|
|
|
427
|
|
|
428 // PSR-0 include paths.
|
|
|
429 if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
|
|
|
430 return $file;
|
|
|
431 }
|
|
|
432
|
|
|
433 return false;
|
|
|
434 }
|
|
|
435 }
|
|
|
436
|
|
|
437 /**
|
|
|
438 * Scope isolated include.
|
|
|
439 *
|
|
|
440 * Prevents access to $this/self from included files.
|
|
|
441 */
|
|
|
442 function includeFile($file)
|
|
|
443 {
|
|
|
444 include $file;
|
|
|
445 }
|
