ExtensionBuilder::getExtensions() - Code Metrics - Inspection of "Improving for stability" - divineniiquaye/rade-di - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#37)

by Divine Niiquaye

created 2022-05-23 13:26 UTC

ExtensionBuilder::getExtensions() A

↳ Parent: ExtensionBuilder

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	3
rs	10
cc	1
nc	1
nop	0

<?php

declare(strict_types=1);

/*
 * This file is part of DivineNii opensource projects.
 *
 * PHP version 7.4 and above required
 *
 * @author    Divine Niiquaye Ibok <[email protected]>
 * @copyright 2021 DivineNii (https://divinenii.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Rade\DI\Extensions;

use Rade\DI\{AbstractContainer, ContainerBuilder};
use Rade\DI\Exceptions\MissingPackageException;
use Symfony\Component\Config\Builder\{ConfigBuilderGenerator, ConfigBuilderGeneratorInterface};
use Symfony\Component\Config\Definition\{ConfigurationInterface, Processor};
use Symfony\Component\Config\Resource\{ClassExistenceResource, FileExistenceResource, FileResource};

/**
 * Provides ability to load container extensions.
 *
 * @author Divine Niiquaye Ibok <[email protected]>
 */
class ExtensionBuilder
{
    protected AbstractContainer $container;
    private ?ConfigBuilderGeneratorInterface $configBuilder = null;

    /** @var array<string,mixed> */
    private array $configuration;

    /** @var array<string,string> */
    private array $aliases = [];

    /** @var array<string,ExtensionInterface|null> */
    private array $extensions = [];

    /**
     * @param array<string,mixed> $config the default configuration for all extensions
     */
    public function __construct(AbstractContainer $container, array $config = [])
    {
        if (\array_key_exists('parameters', $config)) {
            $container->parameters += $config['parameters'];
            unset($config['parameters']);
        }

        $this->container = $container;
        $this->configuration = $config;
    }

    /**
     * Enable Generating ConfigBuilders to help create valid config.
     */
    public function setConfigBuilderGenerator(string $outputDir): void
    {
        $this->configBuilder = new ConfigBuilderGenerator($outputDir);
    }

    /**
     * Get a registered extension instance for extending purpose or etc.
     */
    public function get(string $extensionName): ?ExtensionInterface
    {
        return $this->extensions[$this->aliases[$extensionName] ?? $extensionName] ?? null;
    }

    /**
     * Checks if extension exists.
     */
    public function has(string $extensionName): bool
    {
        return \array_key_exists($this->aliases[$extensionName] ?? $extensionName, $this->extensions);
    }

    /**
     * Get all loaded extensions.
     *
     * @return array<string,ExtensionInterface>
     */
    public function getExtensions(): array
    {
        return $this->extensions;
    }

    /**
     * Get all loaded extension configs.
     *
     * @return array<int|string,mixed>
     */
    public function getConfigs(): array
    {
        return $this->configuration;
    }

    /**
     * Get all extensions configuration.
     *
     * @return array<string,mixed>
     */
    public function getConfig(string $extensionName, string $parent = null)
    {
        $configuration = &$this->configuration;

        if (!(\array_key_exists($extensionName, $this->extensions) || \array_key_exists($extensionName, $this->aliases))) {
            throw new \InvalidArgumentException(\sprintf('The extension "%s" provided in not valid, must be an extension\'s class name or alias.', $extensionName));
        }

        if ($hasParent = isset($parent, $configuration[$parent])) {
            $configuration = &$configuration[$parent];
        }
        $config = &$configuration[$extensionName] ?? [];

        if (false !== ($aliasedId = \array_search($extensionName, $this->aliases)) && isset($configuration[$aliasedId])) {
            $aliased = $configuration[$aliasedId] ?? [];
            $config = \is_array($aliased) ? $this->mergeConfig($config ?? [], $aliased, false) : $aliased;

            if ($hasParent) {
                unset($this->configuration[$parent][$aliasedId]);
            } else {
                unset($this->configuration[$aliasedId]);
            }
        }

        return $config;
    }

    /**
     * Modify the default configuration for an extension.
     *
     * @param array<string,mixed> $configuration
     * @param bool                $replace       If true, integer keys values will be replaceable
     */
    public function modifyConfig(string $extensionName, array $configuration, string $parent = null, bool $replace = false): void
    {
        if (!\array_key_exists($extensionName, $this->extensions)) {
            throw new \InvalidArgumentException(\sprintf('The extension "%s" provided in not valid, must be an extension\'s class name.', $extensionName));
        }

        if (!empty($defaults = $this->getConfig($extensionName, $parent))) {
            $values = $this->mergeConfig($defaults, $configuration, $replace);

            if (isset($parent, $this->configuration[$parent])) {
                $this->configuration[$parent][$extensionName] = $values;
            } else {
                $this->configuration[$extensionName] = $values;
            }
        } else {
            $this->configuration[$extensionName] = $configuration;
        }
    }

    /**
     * Loads a set of container extensions.
     *
     * You can map an extension class name to a priority index else if
     * declared as an array with arguments the third index is termed as priority value.
     *
     * Example:
     * [
     *    PhpExtension::class,
     *    CoreExtension::class => -1,
     *    [ProjectExtension::class, ['%project.dir%']],
     * ]
     *
     * @param array<int,mixed> $extensions
     */
    public function load(array $extensions): void
    {
        $this->container->runScope([ExtensionInterface::BUILDER => $this], function () use ($extensions): void {
            /** @var array<int,BootExtensionInterface> */
            $afterLoading = [];

            $this->bootExtensions($extensions, $afterLoading);

            foreach (\array_reverse($afterLoading) as $bootable) {
                $bootable->boot($this->container);
            }
        });
    }

    /**
     * Resolve extensions and register them.
     *
     * @param mixed[]                           $extensions
     * @param array<int,BootExtensionInterface> $afterLoading
     */
    private function bootExtensions(array $extensions, array &$afterLoading, string $extraKey = null): void
    {
        $container = $this->container;

        foreach ($this->sortExtensions($extensions) as $resolved) {
            if ($resolved instanceof DebugExtensionInterface && $resolved->inDevelopment() !== $container->parameters['debug']) {
                continue;
            }

            if ($container instanceof ContainerBuilder) {
                $container->addResource(new ClassExistenceResource(($ref = new \ReflectionClass($resolved))->getName(), false));
                $container->addResource(new FileExistenceResource($rPath = $ref->getFileName()));
                $container->addResource(new FileResource($rPath));
            }

            if ($resolved instanceof RequiredPackagesInterface) {
                $this->ensureRequiredPackagesAvailable($resolved);
            }

            if ($resolved instanceof DependenciesInterface) {
                $this->bootExtensions($resolved->dependencies(), $afterLoading, \method_exists($resolved, 'dependOnConfigKey') ? $resolved->dependOnConfigKey() : $extraKey);
            }
            $configuration = $this->getConfig($id = \get_class($resolved), $extraKey);

            if ($resolved instanceof ConfigurationInterface) {
                if (null !== $this->configBuilder && \is_string($configuration)) {
                    $configLoader = $this->configBuilder->build($resolved)();

                    if (\file_exists($configuration = $container->parameter($configuration))) {
                        (include $configuration)($configLoader);
                    }
                    $configuration = $configLoader->toArray();

                    if (isset($extraKey, $this->configuration[$extraKey][$id])) {
                        $this->configuration[$extraKey][$id] = $configuration;
                    } else {
                        $this->configuration[$id] = $configuration;
                    }
                } else {
                    $treeBuilder = $resolved->getConfigTreeBuilder()->buildTree();
                    $configuration = (new Processor())->process($treeBuilder, [$treeBuilder->getName() => $configuration]);
                }
            }
            $resolved->register($container, $configuration ?? []);

            if ($resolved instanceof BootExtensionInterface) {
                $afterLoading[] = $resolved;
            }
        }
    }

    /**
     * Sort extensions by priority.
     *
     * @param mixed[] $extensions container extensions with their priority as key
     *
     * @return array<string,ExtensionInterface>
     */
    private function sortExtensions(array $extensions): array
    {
        if (0 === \count($extensions)) {
            return [];
        }
        $passes = [];

        foreach ($extensions as $offset => $extension) {
            $index = 0;

            if (\is_int($extension)) {
                [$index, $extension] = [$extension, $offset];
            } elseif (\is_array($extension) && isset($extension[2])) {
                $index = $extension[2];
            }
            [$extension, $args] = \is_array($extension) ? $extension : [$extension, []];

            if ($this->container instanceof ContainerBuilder) {
                $resolved = (new \ReflectionClass($extension))->newInstanceArgs(\array_map(fn ($v) => \is_string($v) ? $this->container->parameter($v) : $v, $args));
            } else {
                $resolved = $this->container->getResolver()->resolveClass($extension, $args);
            }

            if ($resolved instanceof AliasedInterface) {
                $aliasedId = $resolved->getAlias();

                if (isset($this->aliases[$aliasedId])) {
                    throw new \RuntimeException(\sprintf('The aliased id "%s" for %s extension class must be unqiue.', $aliasedId, $extension));
                }
                $this->aliases[$aliasedId] = $extension;
            }
            $passes[$index][] = $this->extensions[$extension] = $resolved;
        }
        \krsort($passes);

        return \array_merge(...$passes); // Flatten the array
    }

    private function ensureRequiredPackagesAvailable(RequiredPackagesInterface $extension): void
    {
        $missingPackages = [];

        foreach ($extension->getRequiredPackages() as $requiredClass => $packageName) {
            if (!\class_exists($requiredClass)) {
                $missingPackages[] = $packageName;
            }
        }

        if (!$missingPackages) {
            return;
        }

        throw new MissingPackageException(\sprintf('Missing package%s, to use the "%s" extension, run: composer require %s', \count($missingPackages) > 1 ? 's' : '', \get_class($extension), \implode(' ', $missingPackages)));
    }

    /**
     * Merges $b into $a.
     */
    private function mergeConfig(array $a, array $b, bool $replace): array
    {
        foreach ($b as $k => $v) {
            if (\array_key_exists($k, $a)) {
                if (!\is_array($v)) {
                    $replace || \is_string($k) ? $a[$k] = $v : $a[] = $v;

                    continue;
                }
                $a[$k] = $this->mergeConfig($a[$k], $v, $replace);
            } else {
                $a[$k] = $v;
            }
        }

        return $a;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of DivineNii opensource projects.
7			*
8			* PHP version 7.4 and above required
9			*
10			* @author Divine Niiquaye Ibok <[email protected]>
11			* @copyright 2021 DivineNii (https://divinenii.com/)
12			* @license https://opensource.org/licenses/BSD-3-Clause License
13			*
14			* For the full copyright and license information, please view the LICENSE
15			* file that was distributed with this source code.
16			*/
17
18			namespace Rade\DI\Extensions;
19
20			use Rade\DI\{AbstractContainer, ContainerBuilder};
21			use Rade\DI\Exceptions\MissingPackageException;
22			use Symfony\Component\Config\Builder\{ConfigBuilderGenerator, ConfigBuilderGeneratorInterface};
23			use Symfony\Component\Config\Definition\{ConfigurationInterface, Processor};
24			use Symfony\Component\Config\Resource\{ClassExistenceResource, FileExistenceResource, FileResource};
25
26			/**
27			* Provides ability to load container extensions.
28			*
29			* @author Divine Niiquaye Ibok <[email protected]>
30			*/
31			class ExtensionBuilder
32			{
33			protected AbstractContainer $container;
34			private ?ConfigBuilderGeneratorInterface $configBuilder = null;
35
36			/** @var array<string,mixed> */
37			private array $configuration;
38
39			/** @var array<string,string> */
40			private array $aliases = [];
41
42			/** @var array<string,ExtensionInterface\|null> */
43			private array $extensions = [];
44
45			/**
46			* @param array<string,mixed> $config the default configuration for all extensions
47			*/
48			public function __construct(AbstractContainer $container, array $config = [])
49			{
50			if (\array_key_exists('parameters', $config)) {
51			$container->parameters += $config['parameters'];
52			unset($config['parameters']);
53			}
54
55			$this->container = $container;
56			$this->configuration = $config;
57			}
58
59			/**
60			* Enable Generating ConfigBuilders to help create valid config.
61			*/
62			public function setConfigBuilderGenerator(string $outputDir): void
63			{
64			$this->configBuilder = new ConfigBuilderGenerator($outputDir);
65			}
66
67			/**
68			* Get a registered extension instance for extending purpose or etc.
69			*/
70			public function get(string $extensionName): ?ExtensionInterface
71			{
72			return $this->extensions[$this->aliases[$extensionName] ?? $extensionName] ?? null;
73			}
74
75			/**
76			* Checks if extension exists.
77			*/
78			public function has(string $extensionName): bool
79			{
80			return \array_key_exists($this->aliases[$extensionName] ?? $extensionName, $this->extensions);
81			}
82
83			/**
84			* Get all loaded extensions.
85			*
86			* @return array<string,ExtensionInterface>
87			*/
88			public function getExtensions(): array
89			{
90			return $this->extensions;
91			}
92
93			/**
94			* Get all loaded extension configs.
95			*
96			* @return array<int\|string,mixed>
97			*/
98			public function getConfigs(): array
99			{
100			return $this->configuration;
101			}
102
103			/**
104			* Get all extensions configuration.
105			*
106			* @return array<string,mixed>
107			*/
108			public function getConfig(string $extensionName, string $parent = null)
109			{
110			$configuration = &$this->configuration;
111
112			if (!(\array_key_exists($extensionName, $this->extensions) \|\| \array_key_exists($extensionName, $this->aliases))) {
113			throw new \InvalidArgumentException(\sprintf('The extension "%s" provided in not valid, must be an extension\'s class name or alias.', $extensionName));
114			}
115
116			if ($hasParent = isset($parent, $configuration[$parent])) {
117			$configuration = &$configuration[$parent];
118			}
119			$config = &$configuration[$extensionName] ?? [];
120
121			if (false !== ($aliasedId = \array_search($extensionName, $this->aliases)) && isset($configuration[$aliasedId])) {
122			$aliased = $configuration[$aliasedId] ?? [];
123			$config = \is_array($aliased) ? $this->mergeConfig($config ?? [], $aliased, false) : $aliased;
124
125			if ($hasParent) {
126			unset($this->configuration[$parent][$aliasedId]);
127			} else {
128			unset($this->configuration[$aliasedId]);
129			}
130			}
131
132			return $config;
133			}
134
135			/**
136			* Modify the default configuration for an extension.
137			*
138			* @param array<string,mixed> $configuration
139			* @param bool $replace If true, integer keys values will be replaceable
140			*/
141			public function modifyConfig(string $extensionName, array $configuration, string $parent = null, bool $replace = false): void
142			{
143			if (!\array_key_exists($extensionName, $this->extensions)) {
144			throw new \InvalidArgumentException(\sprintf('The extension "%s" provided in not valid, must be an extension\'s class name.', $extensionName));
145			}
146
147			if (!empty($defaults = $this->getConfig($extensionName, $parent))) {
148			$values = $this->mergeConfig($defaults, $configuration, $replace);
149
150			if (isset($parent, $this->configuration[$parent])) {
151			$this->configuration[$parent][$extensionName] = $values;
152			} else {
153			$this->configuration[$extensionName] = $values;
154			}
155			} else {
156			$this->configuration[$extensionName] = $configuration;
157			}
158			}
159
160			/**
161			* Loads a set of container extensions.
162			*
163			* You can map an extension class name to a priority index else if
164			* declared as an array with arguments the third index is termed as priority value.
165			*
166			* Example:
167			* [
168			* PhpExtension::class,
169			* CoreExtension::class => -1,
170			* [ProjectExtension::class, ['%project.dir%']],
171			* ]
172			*
173			* @param array<int,mixed> $extensions
174			*/
175			public function load(array $extensions): void
176			{
177			$this->container->runScope([ExtensionInterface::BUILDER => $this], function () use ($extensions): void {
178			/** @var array<int,BootExtensionInterface> */
179			$afterLoading = [];
180
181			$this->bootExtensions($extensions, $afterLoading);
182
183			foreach (\array_reverse($afterLoading) as $bootable) {
184			$bootable->boot($this->container);
185			}
186			});
187			}
188
189			/**
190			* Resolve extensions and register them.
191			*
192			* @param mixed[] $extensions
193			* @param array<int,BootExtensionInterface> $afterLoading
194			*/
195			private function bootExtensions(array $extensions, array &$afterLoading, string $extraKey = null): void
196			{
197			$container = $this->container;
198
199			foreach ($this->sortExtensions($extensions) as $resolved) {
200			if ($resolved instanceof DebugExtensionInterface && $resolved->inDevelopment() !== $container->parameters['debug']) {
201			continue;
202			}
203
204			if ($container instanceof ContainerBuilder) {
205			$container->addResource(new ClassExistenceResource(($ref = new \ReflectionClass($resolved))->getName(), false));
206			$container->addResource(new FileExistenceResource($rPath = $ref->getFileName()));
207			$container->addResource(new FileResource($rPath));
208			}
209
210			if ($resolved instanceof RequiredPackagesInterface) {
211			$this->ensureRequiredPackagesAvailable($resolved);
212			}
213
214			if ($resolved instanceof DependenciesInterface) {
215			$this->bootExtensions($resolved->dependencies(), $afterLoading, \method_exists($resolved, 'dependOnConfigKey') ? $resolved->dependOnConfigKey() : $extraKey);
216			}
217			$configuration = $this->getConfig($id = \get_class($resolved), $extraKey);
218
219			if ($resolved instanceof ConfigurationInterface) {
220			if (null !== $this->configBuilder && \is_string($configuration)) {
221			$configLoader = $this->configBuilder->build($resolved)();
222
223			if (\file_exists($configuration = $container->parameter($configuration))) {
224			(include $configuration)($configLoader);
225			}
226			$configuration = $configLoader->toArray();
227
228			if (isset($extraKey, $this->configuration[$extraKey][$id])) {
229			$this->configuration[$extraKey][$id] = $configuration;
230			} else {
231			$this->configuration[$id] = $configuration;
232			}
233			} else {
234			$treeBuilder = $resolved->getConfigTreeBuilder()->buildTree();
235			$configuration = (new Processor())->process($treeBuilder, [$treeBuilder->getName() => $configuration]);
236			}
237			}
238			$resolved->register($container, $configuration ?? []);
239
240			if ($resolved instanceof BootExtensionInterface) {
241			$afterLoading[] = $resolved;
242			}
243			}
244			}
245
246			/**
247			* Sort extensions by priority.
248			*
249			* @param mixed[] $extensions container extensions with their priority as key
250			*
251			* @return array<string,ExtensionInterface>
252			*/
253			private function sortExtensions(array $extensions): array
254			{
255			if (0 === \count($extensions)) {
256			return [];
257			}
258			$passes = [];
259
260			foreach ($extensions as $offset => $extension) {
261			$index = 0;
262
263			if (\is_int($extension)) {
264			[$index, $extension] = [$extension, $offset];
265			} elseif (\is_array($extension) && isset($extension[2])) {
266			$index = $extension[2];
267			}
268			[$extension, $args] = \is_array($extension) ? $extension : [$extension, []];
269
270			if ($this->container instanceof ContainerBuilder) {
271			$resolved = (new \ReflectionClass($extension))->newInstanceArgs(\array_map(fn ($v) => \is_string($v) ? $this->container->parameter($v) : $v, $args));
272			} else {
273			$resolved = $this->container->getResolver()->resolveClass($extension, $args);
274			}
275
276			if ($resolved instanceof AliasedInterface) {
277			$aliasedId = $resolved->getAlias();
278
279			if (isset($this->aliases[$aliasedId])) {
280			throw new \RuntimeException(\sprintf('The aliased id "%s" for %s extension class must be unqiue.', $aliasedId, $extension));
281			}
282			$this->aliases[$aliasedId] = $extension;
283			}
284			$passes[$index][] = $this->extensions[$extension] = $resolved;
285			}
286			\krsort($passes);
287
288			return \array_merge(...$passes); // Flatten the array
289			}
290
291			private function ensureRequiredPackagesAvailable(RequiredPackagesInterface $extension): void
292			{
293			$missingPackages = [];
294
295			foreach ($extension->getRequiredPackages() as $requiredClass => $packageName) {
296			if (!\class_exists($requiredClass)) {
297			$missingPackages[] = $packageName;
298			}
299			}
300
301			if (!$missingPackages) {
302			return;
303			}
304
305			throw new MissingPackageException(\sprintf('Missing package%s, to use the "%s" extension, run: composer require %s', \count($missingPackages) > 1 ? 's' : '', \get_class($extension), \implode(' ', $missingPackages)));
306			}
307
308			/**
309			* Merges $b into $a.
310			*/
311			private function mergeConfig(array $a, array $b, bool $replace): array
312			{
313			foreach ($b as $k => $v) {
314			if (\array_key_exists($k, $a)) {
315			if (!\is_array($v)) {
316			$replace \|\| \is_string($k) ? $a[$k] = $v : $a[] = $v;
317
318			continue;
319			}
320			$a[$k] = $this->mergeConfig($a[$k], $v, $replace);
321			} else {
322			$a[$k] = $v;
323			}
324			}
325
326			return $a;
327			}
328			}
329

divineniiquaye / rade-di

Pull Request — master (#37)

ExtensionBuilder::getExtensions() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like