Namespaces

Classes

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 https://www.php-fig.org/psr/psr-0/
41: * @see https://www.php-fig.org/psr/psr-4/
42: */
43: class ClassLoader
44: {
45: /** @var \Closure(string):void */
46: private static $includeFile;
47:
48: /** @var string|null */
49: private $vendorDir;
50:
51: // PSR-4
52: /**
53: * @var array<string, array<string, int>>
54: */
55: private $prefixLengthsPsr4 = array();
56: /**
57: * @var array<string, list<string>>
58: */
59: private $prefixDirsPsr4 = array();
60: /**
61: * @var list<string>
62: */
63: private $fallbackDirsPsr4 = array();
64:
65: // PSR-0
66: /**
67: * List of PSR-0 prefixes
68: *
69: * Structured as array('F (first letter)' => array('Foo\Bar (full prefix)' => array('path', 'path2')))
70: *
71: * @var array<string, array<string, list<string>>>
72: */
73: private $prefixesPsr0 = array();
74: /**
75: * @var list<string>
76: */
77: private $fallbackDirsPsr0 = array();
78:
79: /** @var bool */
80: private $useIncludePath = false;
81:
82: /**
83: * @var array<string, string>
84: */
85: private $classMap = array();
86:
87: /** @var bool */
88: private $classMapAuthoritative = false;
89:
90: /**
91: * @var array<string, bool>
92: */
93: private $missingClasses = array();
94:
95: /** @var string|null */
96: private $apcuPrefix;
97:
98: /**
99: * @var array<string, self>
100: */
101: private static $registeredLoaders = array();
102:
103: /**
104: * @param string|null $vendorDir
105: */
106: public function __construct($vendorDir = null)
107: {
108: $this->vendorDir = $vendorDir;
109: self::initializeIncludeClosure();
110: }
111:
112: /**
113: * @return array<string, list<string>>
114: */
115: public function getPrefixes()
116: {
117: if (!empty($this->prefixesPsr0)) {
118: return call_user_func_array('array_merge', array_values($this->prefixesPsr0));
119: }
120:
121: return array();
122: }
123:
124: /**
125: * @return array<string, list<string>>
126: */
127: public function getPrefixesPsr4()
128: {
129: return $this->prefixDirsPsr4;
130: }
131:
132: /**
133: * @return list<string>
134: */
135: public function getFallbackDirs()
136: {
137: return $this->fallbackDirsPsr0;
138: }
139:
140: /**
141: * @return list<string>
142: */
143: public function getFallbackDirsPsr4()
144: {
145: return $this->fallbackDirsPsr4;
146: }
147:
148: /**
149: * @return array<string, string> Array of classname => path
150: */
151: public function getClassMap()
152: {
153: return $this->classMap;
154: }
155:
156: /**
157: * @param array<string, string> $classMap Class to filename map
158: *
159: * @return void
160: */
161: public function addClassMap(array $classMap)
162: {
163: if ($this->classMap) {
164: $this->classMap = array_merge($this->classMap, $classMap);
165: } else {
166: $this->classMap = $classMap;
167: }
168: }
169:
170: /**
171: * Registers a set of PSR-0 directories for a given prefix, either
172: * appending or prepending to the ones previously set for this prefix.
173: *
174: * @param string $prefix The prefix
175: * @param list<string>|string $paths The PSR-0 root directories
176: * @param bool $prepend Whether to prepend the directories
177: *
178: * @return void
179: */
180: public function add($prefix, $paths, $prepend = false)
181: {
182: $paths = (array) $paths;
183: if (!$prefix) {
184: if ($prepend) {
185: $this->fallbackDirsPsr0 = array_merge(
186: $paths,
187: $this->fallbackDirsPsr0
188: );
189: } else {
190: $this->fallbackDirsPsr0 = array_merge(
191: $this->fallbackDirsPsr0,
192: $paths
193: );
194: }
195:
196: return;
197: }
198:
199: $first = $prefix[0];
200: if (!isset($this->prefixesPsr0[$first][$prefix])) {
201: $this->prefixesPsr0[$first][$prefix] = $paths;
202:
203: return;
204: }
205: if ($prepend) {
206: $this->prefixesPsr0[$first][$prefix] = array_merge(
207: $paths,
208: $this->prefixesPsr0[$first][$prefix]
209: );
210: } else {
211: $this->prefixesPsr0[$first][$prefix] = array_merge(
212: $this->prefixesPsr0[$first][$prefix],
213: $paths
214: );
215: }
216: }
217:
218: /**
219: * Registers a set of PSR-4 directories for a given namespace, either
220: * appending or prepending to the ones previously set for this namespace.
221: *
222: * @param string $prefix The prefix/namespace, with trailing '\\'
223: * @param list<string>|string $paths The PSR-4 base directories
224: * @param bool $prepend Whether to prepend the directories
225: *
226: * @throws \InvalidArgumentException
227: *
228: * @return void
229: */
230: public function addPsr4($prefix, $paths, $prepend = false)
231: {
232: $paths = (array) $paths;
233: if (!$prefix) {
234: // Register directories for the root namespace.
235: if ($prepend) {
236: $this->fallbackDirsPsr4 = array_merge(
237: $paths,
238: $this->fallbackDirsPsr4
239: );
240: } else {
241: $this->fallbackDirsPsr4 = array_merge(
242: $this->fallbackDirsPsr4,
243: $paths
244: );
245: }
246: } elseif (!isset($this->prefixDirsPsr4[$prefix])) {
247: // Register directories for a new namespace.
248: $length = strlen($prefix);
249: if ('\\' !== $prefix[$length - 1]) {
250: throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
251: }
252: $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
253: $this->prefixDirsPsr4[$prefix] = $paths;
254: } elseif ($prepend) {
255: // Prepend directories for an already registered namespace.
256: $this->prefixDirsPsr4[$prefix] = array_merge(
257: $paths,
258: $this->prefixDirsPsr4[$prefix]
259: );
260: } else {
261: // Append directories for an already registered namespace.
262: $this->prefixDirsPsr4[$prefix] = array_merge(
263: $this->prefixDirsPsr4[$prefix],
264: $paths
265: );
266: }
267: }
268:
269: /**
270: * Registers a set of PSR-0 directories for a given prefix,
271: * replacing any others previously set for this prefix.
272: *
273: * @param string $prefix The prefix
274: * @param list<string>|string $paths The PSR-0 base directories
275: *
276: * @return void
277: */
278: public function set($prefix, $paths)
279: {
280: if (!$prefix) {
281: $this->fallbackDirsPsr0 = (array) $paths;
282: } else {
283: $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths;
284: }
285: }
286:
287: /**
288: * Registers a set of PSR-4 directories for a given namespace,
289: * replacing any others previously set for this namespace.
290: *
291: * @param string $prefix The prefix/namespace, with trailing '\\'
292: * @param list<string>|string $paths The PSR-4 base directories
293: *
294: * @throws \InvalidArgumentException
295: *
296: * @return void
297: */
298: public function setPsr4($prefix, $paths)
299: {
300: if (!$prefix) {
301: $this->fallbackDirsPsr4 = (array) $paths;
302: } else {
303: $length = strlen($prefix);
304: if ('\\' !== $prefix[$length - 1]) {
305: throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator.");
306: }
307: $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length;
308: $this->prefixDirsPsr4[$prefix] = (array) $paths;
309: }
310: }
311:
312: /**
313: * Turns on searching the include path for class files.
314: *
315: * @param bool $useIncludePath
316: *
317: * @return void
318: */
319: public function setUseIncludePath($useIncludePath)
320: {
321: $this->useIncludePath = $useIncludePath;
322: }
323:
324: /**
325: * Can be used to check if the autoloader uses the include path to check
326: * for classes.
327: *
328: * @return bool
329: */
330: public function getUseIncludePath()
331: {
332: return $this->useIncludePath;
333: }
334:
335: /**
336: * Turns off searching the prefix and fallback directories for classes
337: * that have not been registered with the class map.
338: *
339: * @param bool $classMapAuthoritative
340: *
341: * @return void
342: */
343: public function setClassMapAuthoritative($classMapAuthoritative)
344: {
345: $this->classMapAuthoritative = $classMapAuthoritative;
346: }
347:
348: /**
349: * Should class lookup fail if not found in the current class map?
350: *
351: * @return bool
352: */
353: public function isClassMapAuthoritative()
354: {
355: return $this->classMapAuthoritative;
356: }
357:
358: /**
359: * APCu prefix to use to cache found/not-found classes, if the extension is enabled.
360: *
361: * @param string|null $apcuPrefix
362: *
363: * @return void
364: */
365: public function setApcuPrefix($apcuPrefix)
366: {
367: $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null;
368: }
369:
370: /**
371: * The APCu prefix in use, or null if APCu caching is not enabled.
372: *
373: * @return string|null
374: */
375: public function getApcuPrefix()
376: {
377: return $this->apcuPrefix;
378: }
379:
380: /**
381: * Registers this instance as an autoloader.
382: *
383: * @param bool $prepend Whether to prepend the autoloader or not
384: *
385: * @return void
386: */
387: public function register($prepend = false)
388: {
389: spl_autoload_register(array($this, 'loadClass'), true, $prepend);
390:
391: if (null === $this->vendorDir) {
392: return;
393: }
394:
395: if ($prepend) {
396: self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
397: } else {
398: unset(self::$registeredLoaders[$this->vendorDir]);
399: self::$registeredLoaders[$this->vendorDir] = $this;
400: }
401: }
402:
403: /**
404: * Unregisters this instance as an autoloader.
405: *
406: * @return void
407: */
408: public function unregister()
409: {
410: spl_autoload_unregister(array($this, 'loadClass'));
411:
412: if (null !== $this->vendorDir) {
413: unset(self::$registeredLoaders[$this->vendorDir]);
414: }
415: }
416:
417: /**
418: * Loads the given class or interface.
419: *
420: * @param string $class The name of the class
421: * @return true|null True if loaded, null otherwise
422: */
423: public function loadClass($class)
424: {
425: if ($file = $this->findFile($class)) {
426: $includeFile = self::$includeFile;
427: $includeFile($file);
428:
429: return true;
430: }
431:
432: return null;
433: }
434:
435: /**
436: * Finds the path to the file where the class is defined.
437: *
438: * @param string $class The name of the class
439: *
440: * @return string|false The path if found, false otherwise
441: */
442: public function findFile($class)
443: {
444: // class map lookup
445: if (isset($this->classMap[$class])) {
446: return $this->classMap[$class];
447: }
448: if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
449: return false;
450: }
451: if (null !== $this->apcuPrefix) {
452: $file = apcu_fetch($this->apcuPrefix.$class, $hit);
453: if ($hit) {
454: return $file;
455: }
456: }
457:
458: $file = $this->findFileWithExtension($class, '.php');
459:
460: // Search for Hack files if we are running on HHVM
461: if (false === $file && defined('HHVM_VERSION')) {
462: $file = $this->findFileWithExtension($class, '.hh');
463: }
464:
465: if (null !== $this->apcuPrefix) {
466: apcu_add($this->apcuPrefix.$class, $file);
467: }
468:
469: if (false === $file) {
470: // Remember that this class does not exist.
471: $this->missingClasses[$class] = true;
472: }
473:
474: return $file;
475: }
476:
477: /**
478: * Returns the currently registered loaders keyed by their corresponding vendor directories.
479: *
480: * @return array<string, self>
481: */
482: public static function getRegisteredLoaders()
483: {
484: return self::$registeredLoaders;
485: }
486:
487: /**
488: * @param string $class
489: * @param string $ext
490: * @return string|false
491: */
492: private function findFileWithExtension($class, $ext)
493: {
494: // PSR-4 lookup
495: $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
496:
497: $first = $class[0];
498: if (isset($this->prefixLengthsPsr4[$first])) {
499: $subPath = $class;
500: while (false !== $lastPos = strrpos($subPath, '\\')) {
501: $subPath = substr($subPath, 0, $lastPos);
502: $search = $subPath . '\\';
503: if (isset($this->prefixDirsPsr4[$search])) {
504: $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
505: foreach ($this->prefixDirsPsr4[$search] as $dir) {
506: if (file_exists($file = $dir . $pathEnd)) {
507: return $file;
508: }
509: }
510: }
511: }
512: }
513:
514: // PSR-4 fallback dirs
515: foreach ($this->fallbackDirsPsr4 as $dir) {
516: if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
517: return $file;
518: }
519: }
520:
521: // PSR-0 lookup
522: if (false !== $pos = strrpos($class, '\\')) {
523: // namespaced class name
524: $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
525: . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
526: } else {
527: // PEAR-like class name
528: $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
529: }
530:
531: if (isset($this->prefixesPsr0[$first])) {
532: foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
533: if (0 === strpos($class, $prefix)) {
534: foreach ($dirs as $dir) {
535: if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
536: return $file;
537: }
538: }
539: }
540: }
541: }
542:
543: // PSR-0 fallback dirs
544: foreach ($this->fallbackDirsPsr0 as $dir) {
545: if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
546: return $file;
547: }
548: }
549:
550: // PSR-0 include paths.
551: if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
552: return $file;
553: }
554:
555: return false;
556: }
557:
558: /**
559: * @return void
560: */
561: private static function initializeIncludeClosure()
562: {
563: if (self::$includeFile !== null) {
564: return;
565: }
566:
567: /**
568: * Scope isolated include.
569: *
570: * Prevents access to $this/self from included files.
571: *
572: * @param string $file
573: * @return void
574: */
575: self::$includeFile = \Closure::bind(static function($file) {
576: include $file;
577: }, null, null);
578: }
579: }
580:
API documentation generated by ApiGen v7.0.0-alpha.6