Facades
2 years ago
Testing
2 years ago
Traits
2 years ago
AggregateServiceProvider.php
2 years ago
Carbon.php
2 years ago
Composer.php
2 years ago
ConfigurationUrlParser.php
2 years ago
DateFactory.php
2 years ago
Env.php
2 years ago
Fluent.php
2 years ago
HigherOrderTapProxy.php
2 years ago
HtmlString.php
2 years ago
InteractsWithTime.php
2 years ago
Js.php
2 years ago
Manager.php
2 years ago
MessageBag.php
2 years ago
MultipleInstanceManager.php
2 years ago
NamespacedItemResolver.php
2 years ago
Optional.php
2 years ago
Pluralizer.php
2 years ago
ProcessUtils.php
2 years ago
Reflector.php
2 years ago
ServiceProvider.php
2 years ago
Str.php
2 years ago
Stringable.php
2 years ago
Timebox.php
2 years ago
ValidatedInput.php
2 years ago
ViewErrorBag.php
2 years ago
helpers.php
2 years ago
NamespacedItemResolver.php
97 lines
| 1 | <?php |
| 2 | |
| 3 | namespace IAWP_SCOPED\Illuminate\Support; |
| 4 | |
| 5 | /** @internal */ |
| 6 | class NamespacedItemResolver |
| 7 | { |
| 8 | /** |
| 9 | * A cache of the parsed items. |
| 10 | * |
| 11 | * @var array |
| 12 | */ |
| 13 | protected $parsed = []; |
| 14 | /** |
| 15 | * Parse a key into namespace, group, and item. |
| 16 | * |
| 17 | * @param string $key |
| 18 | * @return array |
| 19 | */ |
| 20 | public function parseKey($key) |
| 21 | { |
| 22 | // If we've already parsed the given key, we'll return the cached version we |
| 23 | // already have, as this will save us some processing. We cache off every |
| 24 | // key we parse so we can quickly return it on all subsequent requests. |
| 25 | if (isset($this->parsed[$key])) { |
| 26 | return $this->parsed[$key]; |
| 27 | } |
| 28 | // If the key does not contain a double colon, it means the key is not in a |
| 29 | // namespace, and is just a regular configuration item. Namespaces are a |
| 30 | // tool for organizing configuration items for things such as modules. |
| 31 | if (\strpos($key, '::') === \false) { |
| 32 | $segments = \explode('.', $key); |
| 33 | $parsed = $this->parseBasicSegments($segments); |
| 34 | } else { |
| 35 | $parsed = $this->parseNamespacedSegments($key); |
| 36 | } |
| 37 | // Once we have the parsed array of this key's elements, such as its groups |
| 38 | // and namespace, we will cache each array inside a simple list that has |
| 39 | // the key and the parsed array for quick look-ups for later requests. |
| 40 | return $this->parsed[$key] = $parsed; |
| 41 | } |
| 42 | /** |
| 43 | * Parse an array of basic segments. |
| 44 | * |
| 45 | * @param array $segments |
| 46 | * @return array |
| 47 | */ |
| 48 | protected function parseBasicSegments(array $segments) |
| 49 | { |
| 50 | // The first segment in a basic array will always be the group, so we can go |
| 51 | // ahead and grab that segment. If there is only one total segment we are |
| 52 | // just pulling an entire group out of the array and not a single item. |
| 53 | $group = $segments[0]; |
| 54 | // If there is more than one segment in this group, it means we are pulling |
| 55 | // a specific item out of a group and will need to return this item name |
| 56 | // as well as the group so we know which item to pull from the arrays. |
| 57 | $item = \count($segments) === 1 ? null : \implode('.', \array_slice($segments, 1)); |
| 58 | return [null, $group, $item]; |
| 59 | } |
| 60 | /** |
| 61 | * Parse an array of namespaced segments. |
| 62 | * |
| 63 | * @param string $key |
| 64 | * @return array |
| 65 | */ |
| 66 | protected function parseNamespacedSegments($key) |
| 67 | { |
| 68 | [$namespace, $item] = \explode('::', $key); |
| 69 | // First we'll just explode the first segment to get the namespace and group |
| 70 | // since the item should be in the remaining segments. Once we have these |
| 71 | // two pieces of data we can proceed with parsing out the item's value. |
| 72 | $itemSegments = \explode('.', $item); |
| 73 | $groupAndItem = \array_slice($this->parseBasicSegments($itemSegments), 1); |
| 74 | return \array_merge([$namespace], $groupAndItem); |
| 75 | } |
| 76 | /** |
| 77 | * Set the parsed value of a key. |
| 78 | * |
| 79 | * @param string $key |
| 80 | * @param array $parsed |
| 81 | * @return void |
| 82 | */ |
| 83 | public function setParsedKey($key, $parsed) |
| 84 | { |
| 85 | $this->parsed[$key] = $parsed; |
| 86 | } |
| 87 | /** |
| 88 | * Flush the cache of parsed keys. |
| 89 | * |
| 90 | * @return void |
| 91 | */ |
| 92 | public function flushParsedKeys() |
| 93 | { |
| 94 | $this->parsed = []; |
| 95 | } |
| 96 | } |
| 97 |