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