Projeto

Geral

Perfil

Estatísticas
| Branch: | Revisão:

expressolivretools / vendor / composer / ClassLoader.php @ master

Histórico | Ver | Anotar | Baixar (14,1 KB)

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
    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
 */
478
function includeFile($file)
479
{
480
    include $file;
481
}