Subversion-Projekte lars-tiefland.laravel_shop

Revision

Details | Letzte Änderung | Log anzeigen | RSS feed

Revision Autor Zeilennr. Zeile
148 lars 1 
<?php
2 
 
3 
namespace Laravel\Tinker;
4 
 
5 
use Illuminate\Support\Str;
6 
use Psy\Shell;
7 
 
8 
class ClassAliasAutoloader
9 
{
10 
    /**
11 
     * The shell instance.
12 
     *
13 
     * @var \Psy\Shell
14 
     */
15 
    protected $shell;
16 
 
17 
    /**
18 
     * All of the discovered classes.
19 
     *
20 
     * @var array
21 
     */
22 
    protected $classes = [];
23 
 
24 
    /**
25 
     * Path to the vendor directory.
26 
     *
27 
     * @var string
28 
     */
29 
    protected $vendorPath;
30 
 
31 
    /**
32 
     * Explicitly included namespaces/classes.
33 
     *
34 
     * @var \Illuminate\Support\Collection
35 
     */
36 
    protected $includedAliases;
37 
 
38 
    /**
39 
     * Excluded namespaces/classes.
40 
     *
41 
     * @var \Illuminate\Support\Collection
42 
     */
43 
    protected $excludedAliases;
44 
 
45 
    /**
46 
     * Register a new alias loader instance.
47 
     *
48 
     * @param  \Psy\Shell  $shell
49 
     * @param  string  $classMapPath
50 
     * @param  array  $includedAliases
51 
     * @param  array  $excludedAliases
52 
     * @return static
53 
     */
54 
    public static function register(Shell $shell, $classMapPath, array $includedAliases = [], array $excludedAliases = [])
55 
    {
56 
        return tap(new static($shell, $classMapPath, $includedAliases, $excludedAliases), function ($loader) {
57 
            spl_autoload_register([$loader, 'aliasClass']);
58 
        });
59 
    }
60 
 
61 
    /**
62 
     * Create a new alias loader instance.
63 
     *
64 
     * @param  \Psy\Shell  $shell
65 
     * @param  string  $classMapPath
66 
     * @param  array  $includedAliases
67 
     * @param  array  $excludedAliases
68 
     * @return void
69 
     */
70 
    public function __construct(Shell $shell, $classMapPath, array $includedAliases = [], array $excludedAliases = [])
71 
    {
72 
        $this->shell = $shell;
73 
        $this->vendorPath = dirname(dirname($classMapPath));
74 
        $this->includedAliases = collect($includedAliases);
75 
        $this->excludedAliases = collect($excludedAliases);
76 
 
77 
        $classes = require $classMapPath;
78 
 
79 
        foreach ($classes as $class => $path) {
80 
            if (! $this->isAliasable($class, $path)) {
81 
                continue;
82 
            }
83 
 
84 
            $name = class_basename($class);
85 
 
86 
            if (! isset($this->classes[$name])) {
87 
                $this->classes[$name] = $class;
88 
            }
89 
        }
90 
    }
91 
 
92 
    /**
93 
     * Find the closest class by name.
94 
     *
95 
     * @param  string  $class
96 
     * @return void
97 
     */
98 
    public function aliasClass($class)
99 
    {
100 
        if (Str::contains($class, '\\')) {
101 
            return;
102 
        }
103 
 
104 
        $fullName = $this->classes[$class] ?? false;
105 
 
106 
        if ($fullName) {
107 
            $this->shell->writeStdout("[!] Aliasing '{$class}' to '{$fullName}' for this Tinker session.\n");
108 
 
109 
            class_alias($fullName, $class);
110 
        }
111 
    }
112 
 
113 
    /**
114 
     * Unregister the alias loader instance.
115 
     *
116 
     * @return void
117 
     */
118 
    public function unregister()
119 
    {
120 
        spl_autoload_unregister([$this, 'aliasClass']);
121 
    }
122 
 
123 
    /**
124 
     * Handle the destruction of the instance.
125 
     *
126 
     * @return void
127 
     */
128 
    public function __destruct()
129 
    {
130 
        $this->unregister();
131 
    }
132 
 
133 
    /**
134 
     * Whether a class may be aliased.
135 
     *
136 
     * @param  string  $class
137 
     * @param  string  $path
138 
     */
139 
    public function isAliasable($class, $path)
140 
    {
141 
        if (! Str::contains($class, '\\')) {
142 
            return false;
143 
        }
144 
 
145 
        if (! $this->includedAliases->filter(function ($alias) use ($class) {
146 
            return Str::startsWith($class, $alias);
147 
        })->isEmpty()) {
148 
            return true;
149 
        }
150 
 
151 
        if (Str::startsWith($path, $this->vendorPath)) {
152 
            return false;
153 
        }
154 
 
155 
        if (! $this->excludedAliases->filter(function ($alias) use ($class) {
156 
            return Str::startsWith($class, $alias);
157 
        })->isEmpty()) {
158 
            return false;
159 
        }
160 
 
161 
        return true;
162 
    }
163 
}