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            return;
315        }
316
317        if ($prepend) {
318            self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders;
319        } else {
320            unset(self::$registeredLoaders[$this->vendorDir]);
321            self::$registeredLoaders[$this->vendorDir] = $this;
322        }
323    }
324
325    /**
326     * Unregisters this instance as an autoloader.
327     */
328    public function unregister()
329    {
330        spl_autoload_unregister(array($this, 'loadClass'));
331
332        if (null !== $this->vendorDir) {
333            unset(self::$registeredLoaders[$this->vendorDir]);
334        }
335    }
336
337    /**
338     * Loads the given class or interface.
339     *
340     * @param  string    $class The name of the class
341     * @return true|null True if loaded, null otherwise
342     */
343    public function loadClass($class)
344    {
345        if ($file = $this->findFile($class)) {
346            includeFile($file);
347
348            return true;
349        }
350
351        return null;
352    }
353
354    /**
355     * Finds the path to the file where the class is defined.
356     *
357     * @param string $class The name of the class
358     *
359     * @return string|false The path if found, false otherwise
360     */
361    public function findFile($class)
362    {
363        // class map lookup
364        if (isset($this->classMap[$class])) {
365            return $this->classMap[$class];
366        }
367        if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) {
368            return false;
369        }
370        if (null !== $this->apcuPrefix) {
371            $file = apcu_fetch($this->apcuPrefix.$class, $hit);
372            if ($hit) {
373                return $file;
374            }
375        }
376
377        $file = $this->findFileWithExtension($class, '.php');
378
379        // Search for Hack files if we are running on HHVM
380        if (false === $file && defined('HHVM_VERSION')) {
381            $file = $this->findFileWithExtension($class, '.hh');
382        }
383
384        if (null !== $this->apcuPrefix) {
385            apcu_add($this->apcuPrefix.$class, $file);
386        }
387
388        if (false === $file) {
389            // Remember that this class does not exist.
390            $this->missingClasses[$class] = true;
391        }
392
393        return $file;
394    }
395
396    /**
397     * Returns the currently registered loaders indexed by their corresponding vendor directories.
398     *
399     * @return self[]
400     */
401    public static function getRegisteredLoaders()
402    {
403        return self::$registeredLoaders;
404    }
405
406    private function findFileWithExtension($class, $ext)
407    {
408        // PSR-4 lookup
409        $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext;
410
411        $first = $class[0];
412        if (isset($this->prefixLengthsPsr4[$first])) {
413            $subPath = $class;
414            while (false !== $lastPos = strrpos($subPath, '\\')) {
415                $subPath = substr($subPath, 0, $lastPos);
416                $search = $subPath . '\\';
417                if (isset($this->prefixDirsPsr4[$search])) {
418                    $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1);
419                    foreach ($this->prefixDirsPsr4[$search] as $dir) {
420                        if (file_exists($file = $dir . $pathEnd)) {
421                            return $file;
422                        }
423                    }
424                }
425            }
426        }
427
428        // PSR-4 fallback dirs
429        foreach ($this->fallbackDirsPsr4 as $dir) {
430            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) {
431                return $file;
432            }
433        }
434
435        // PSR-0 lookup
436        if (false !== $pos = strrpos($class, '\\')) {
437            // namespaced class name
438            $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1)
439                . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR);
440        } else {
441            // PEAR-like class name
442            $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext;
443        }
444
445        if (isset($this->prefixesPsr0[$first])) {
446            foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) {
447                if (0 === strpos($class, $prefix)) {
448                    foreach ($dirs as $dir) {
449                        if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
450                            return $file;
451                        }
452                    }
453                }
454            }
455        }
456
457        // PSR-0 fallback dirs
458        foreach ($this->fallbackDirsPsr0 as $dir) {
459            if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) {
460                return $file;
461            }
462        }
463
464        // PSR-0 include paths.
465        if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) {
466            return $file;
467        }
468
469        return false;
470    }
471}
472
473/**
474 * Scope isolated include.
475 *
476 * Prevents access to $this/self from included files.
477 */
478function includeFile($file)
479{
480    include $file;
481}
482