CoreData::addRoutes() - Code Metrics - Inspection of "Update to changes in settings subsystem." - limoncello-php-dist/application - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 146147...1776d4 )

by Neomerx

created 2017-11-13 06:05 UTC

CoreData::addRoutes() A

↳ Parent: CoreData

Complexity

Conditions	4
Paths	6

Size

Total Lines	19
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	19
ccs	9
cts	9
cp	1
rs	9.2
c	0
b	0
f	0
cc	4
eloc	9
nc	6
nop	1
crap	4

<?php namespace Limoncello\Application\CoreSettings;

/**
 * Copyright 2015-2017 [email protected]
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

use FastRoute\DataGenerator\GroupCountBased as GroupCountBasedGenerator;
use Generator;
use Limoncello\Contracts\Application\ContainerConfiguratorInterface;
use Limoncello\Contracts\Application\MiddlewareInterface;
use Limoncello\Contracts\Application\RoutesConfiguratorInterface;
use Limoncello\Contracts\Container\ContainerInterface;
use Limoncello\Contracts\Provider\ProvidesContainerConfiguratorsInterface;
use Limoncello\Contracts\Provider\ProvidesMiddlewareInterface;
use Limoncello\Contracts\Provider\ProvidesRouteConfiguratorsInterface;
use Limoncello\Contracts\Routing\GroupInterface;
use Limoncello\Contracts\Routing\RouterInterface;
use Limoncello\Core\Application\BaseCoreData;
use Limoncello\Core\Reflection\CheckCallableTrait;
use Limoncello\Core\Reflection\ClassIsTrait;
use Limoncello\Core\Routing\Dispatcher\GroupCountBased as GroupCountBasedDispatcher;
use Limoncello\Core\Routing\Group;
use Limoncello\Core\Routing\Router;

/**
 * @package Limoncello\Application
 *
 * @SuppressWarnings(PHPMD.CouplingBetweenObjects)
 */
class CoreData extends BaseCoreData
{
    use ClassIsTrait, CheckCallableTrait;

    /**
     * @var string
     */
    private $routesPath;

    /**
     * @var string
     */
    private $configuratorsPath;

    /**
     * @var string[]
     */
    private $providerClasses;

    /**
     * @param string   $routesPath
     * @param string   $configuratorsPath
     * @param string[] $providerClasses
     */
    public function __construct(string $routesPath, string $configuratorsPath, array $providerClasses)
    {
        $this->routesPath        = $routesPath;
        $this->configuratorsPath = $configuratorsPath;
        $this->providerClasses   = $providerClasses;
    }

    /**
     * @inheritdoc
     */
    public function get(): array
    {
        list ($generatorClass, $dispatcherClass) = $this->getGeneratorAndDispatcherClasses();

        $routesData = $this
            ->createRouter($generatorClass, $dispatcherClass)
            ->getCachedRoutes($this->addRoutes($this->createGroup()));

        $globalConfigurators = iterator_to_array($this->getGlobalContainerConfigurators(), false);
        $globalMiddleware    = iterator_to_array($this->getGlobalMiddleWareHandlers(), false);

        return [
            static::KEY_ROUTER_PARAMS                  => [
                static::KEY_ROUTER_PARAMS__GENERATOR  => $generatorClass,
                static::KEY_ROUTER_PARAMS__DISPATCHER => $dispatcherClass,
            ],
            static::KEY_ROUTES_DATA                    => $routesData,
            static::KEY_GLOBAL_CONTAINER_CONFIGURATORS => $globalConfigurators,
            static::KEY_GLOBAL_MIDDLEWARE              => $globalMiddleware,
        ];
    }

    /**
     * @return array
     */
    protected function getGeneratorAndDispatcherClasses(): array
    {
        return [GroupCountBasedGenerator::class, GroupCountBasedDispatcher::class];
    }

    /**
     * @return Generator
     */
    protected function getGlobalContainerConfigurators(): Generator
    {
        $interfaceName = ContainerConfiguratorInterface::class;
        foreach ($this->selectClasses($this->getConfiguratorsPath(), $interfaceName) as $configuratorClass) {
            $configurator = [$configuratorClass, ContainerConfiguratorInterface::CONTAINER_METHOD_NAME];
            assert($this->isValidContainerConfigurator($configurator) === true);
            yield $configurator;
        }

        $interfaceName = ProvidesContainerConfiguratorsInterface::class;
        foreach ($this->selectClassImplements($this->getProviderClasses(), $interfaceName) as $providerClass) {
            /** @var ProvidesContainerConfiguratorsInterface $providerClass */
            foreach ($providerClass::getContainerConfigurators() as $configuratorClass) {
                $configurator = [$configuratorClass, ContainerConfiguratorInterface::CONTAINER_METHOD_NAME];
                assert($this->isValidContainerConfigurator($configurator) === true);
                yield $configurator;
            }
        }
    }

    /**
     * @param GroupInterface $group
     *
     * @return GroupInterface
     */
    protected function addRoutes(GroupInterface $group): GroupInterface
    {
        $interfaceName = RoutesConfiguratorInterface::class;
        foreach ($this->selectClasses($this->getRoutesPath(), $interfaceName) as $routesConfClass) {
            /** @var RoutesConfiguratorInterface $routesConfClass */
            $routesConfClass::configureRoutes($group);
        }

        $interfaceName = ProvidesRouteConfiguratorsInterface::class;
        foreach ($this->selectClassImplements($this->getProviderClasses(), $interfaceName) as $providerClass) {
            /** @var ProvidesRouteConfiguratorsInterface $providerClass */
            foreach ($providerClass::getRouteConfigurators() as $routesConfClass) {
                /** @var RoutesConfiguratorInterface $routesConfClass */
                $routesConfClass::configureRoutes($group);
            }
        }

        return $group;
    }

    /**
     * @return Generator
     */
    protected function getGlobalMiddleWareHandlers(): Generator
    {
        // select global middleware from routes
        foreach ($this->selectClasses($this->getRoutesPath(), RoutesConfiguratorInterface::class) as $selectClass) {
            /** @var RoutesConfiguratorInterface $selectClass */
            foreach ($selectClass::getMiddleware() as $middlewareClass) {
                $handler = [$middlewareClass, MiddlewareInterface::MIDDLEWARE_METHOD_NAME];
                yield $handler;
            }
        }

        // select global middleware from providers
        $interfaceName = ProvidesMiddlewareInterface::class;
        foreach ($this->selectClassImplements($this->getProviderClasses(), $interfaceName) as $providerClass) {
            /** @var ProvidesMiddlewareInterface $providerClass */
            foreach ($providerClass::getMiddleware() as $middlewareClass) {
                $handler = [$middlewareClass, MiddlewareInterface::MIDDLEWARE_METHOD_NAME];
                yield $handler;
            }
        }
    }

    /**
     * @return GroupInterface
     */
    protected function createGroup(): GroupInterface
    {
        return new Group();
    }

    /**
     * @param string $generatorClass
     * @param string $dispatcherClass
     *
     * @return RouterInterface
     */
    protected function createRouter(string $generatorClass, string $dispatcherClass): RouterInterface
    {
        return new Router($generatorClass, $dispatcherClass);
    }

    /**
     * @return string
     */
    protected function getConfiguratorsPath(): string
    {
        return $this->configuratorsPath;
    }

    /**
     * @return string[]
     */
    protected function getProviderClasses(): array
    {
        return $this->providerClasses;
    }

    /**
     * @return string
     */
    protected function getRoutesPath(): string
    {
        return $this->routesPath;
    }

    /**
     * @param string|array|callable $mightBeConfigurator
     *
     * @return bool
     */
    private function isValidContainerConfigurator($mightBeConfigurator): bool
    {
        return $this->checkPublicStaticCallable($mightBeConfigurator, [ContainerInterface::class]);
    }
}


1		<?php namespace Limoncello\Application\CoreSettings;
2
3		/**
4		* Copyright 2015-2017 [email protected]
5		*
6		* Licensed under the Apache License, Version 2.0 (the "License");
7		* you may not use this file except in compliance with the License.
8		* You may obtain a copy of the License at
9		*
10		* http://www.apache.org/licenses/LICENSE-2.0
11		*
12		* Unless required by applicable law or agreed to in writing, software
13		* distributed under the License is distributed on an "AS IS" BASIS,
14		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15		* See the License for the specific language governing permissions and
16		* limitations under the License.
17		*/
18
19		use FastRoute\DataGenerator\GroupCountBased as GroupCountBasedGenerator;
20		use Generator;
21		use Limoncello\Contracts\Application\ContainerConfiguratorInterface;
22		use Limoncello\Contracts\Application\MiddlewareInterface;
23		use Limoncello\Contracts\Application\RoutesConfiguratorInterface;
24		use Limoncello\Contracts\Container\ContainerInterface;
25		use Limoncello\Contracts\Provider\ProvidesContainerConfiguratorsInterface;
26		use Limoncello\Contracts\Provider\ProvidesMiddlewareInterface;
27		use Limoncello\Contracts\Provider\ProvidesRouteConfiguratorsInterface;
28		use Limoncello\Contracts\Routing\GroupInterface;
29		use Limoncello\Contracts\Routing\RouterInterface;
30		use Limoncello\Core\Application\BaseCoreData;
31		use Limoncello\Core\Reflection\CheckCallableTrait;
32		use Limoncello\Core\Reflection\ClassIsTrait;
33		use Limoncello\Core\Routing\Dispatcher\GroupCountBased as GroupCountBasedDispatcher;
34		use Limoncello\Core\Routing\Group;
35		use Limoncello\Core\Routing\Router;
36
37		/**
38		* @package Limoncello\Application
39		*
40		* @SuppressWarnings(PHPMD.CouplingBetweenObjects)
41		*/
42		class CoreData extends BaseCoreData
43		{
44		use ClassIsTrait, CheckCallableTrait;
45
46		/**
47		* @var string
48		*/
49		private $routesPath;
50
51		/**
52		* @var string
53		*/
54		private $configuratorsPath;
55
56		/**
57		* @var string[]
58		*/
59		private $providerClasses;
60
61		/**
62		* @param string $routesPath
63		* @param string $configuratorsPath
64		* @param string[] $providerClasses
65		*/
66	7	public function __construct(string $routesPath, string $configuratorsPath, array $providerClasses)
67		{
68	7	$this->routesPath = $routesPath;
69	7	$this->configuratorsPath = $configuratorsPath;
70	7	$this->providerClasses = $providerClasses;
71		}
72
73		/**
74		* @inheritdoc
75		*/
76	7	public function get(): array
77		{
78	7	list ($generatorClass, $dispatcherClass) = $this->getGeneratorAndDispatcherClasses();
79
80		$routesData = $this
81	7	->createRouter($generatorClass, $dispatcherClass)
82	7	->getCachedRoutes($this->addRoutes($this->createGroup()));
83
84	7	$globalConfigurators = iterator_to_array($this->getGlobalContainerConfigurators(), false);
85	7	$globalMiddleware = iterator_to_array($this->getGlobalMiddleWareHandlers(), false);
86
87		return [
88	7	static::KEY_ROUTER_PARAMS => [
89	7	static::KEY_ROUTER_PARAMS__GENERATOR => $generatorClass,
90	7	static::KEY_ROUTER_PARAMS__DISPATCHER => $dispatcherClass,
91		],
92	7	static::KEY_ROUTES_DATA => $routesData,
93	7	static::KEY_GLOBAL_CONTAINER_CONFIGURATORS => $globalConfigurators,
94	7	static::KEY_GLOBAL_MIDDLEWARE => $globalMiddleware,
95		];
96		}
97
98		/**
99		* @return array
100		*/
101	7	protected function getGeneratorAndDispatcherClasses(): array
102		{
103	7	return [GroupCountBasedGenerator::class, GroupCountBasedDispatcher::class];
104		}
105
106		/**
107		* @return Generator
108		*/
109	7	protected function getGlobalContainerConfigurators(): Generator
110		{
111	7	$interfaceName = ContainerConfiguratorInterface::class;
112	7	foreach ($this->selectClasses($this->getConfiguratorsPath(), $interfaceName) as $configuratorClass) {
113	7	$configurator = [$configuratorClass, ContainerConfiguratorInterface::CONTAINER_METHOD_NAME];
114	7	assert($this->isValidContainerConfigurator($configurator) === true);
115	7	yield $configurator;
116		}
117
118	7	$interfaceName = ProvidesContainerConfiguratorsInterface::class;
119	7	foreach ($this->selectClassImplements($this->getProviderClasses(), $interfaceName) as $providerClass) {
120		/** @var ProvidesContainerConfiguratorsInterface $providerClass */
121	7	foreach ($providerClass::getContainerConfigurators() as $configuratorClass) {
122	7	$configurator = [$configuratorClass, ContainerConfiguratorInterface::CONTAINER_METHOD_NAME];
123	7	assert($this->isValidContainerConfigurator($configurator) === true);
124	7	yield $configurator;
125		}
126		}
127		}
128
129		/**
130		* @param GroupInterface $group
131		*
132		* @return GroupInterface
133		*/
134	7	protected function addRoutes(GroupInterface $group): GroupInterface
135		{
136	7	$interfaceName = RoutesConfiguratorInterface::class;
137	7	foreach ($this->selectClasses($this->getRoutesPath(), $interfaceName) as $routesConfClass) {
138		/** @var RoutesConfiguratorInterface $routesConfClass */
139	7	$routesConfClass::configureRoutes($group);
140		}
141
142	7	$interfaceName = ProvidesRouteConfiguratorsInterface::class;
143	7	foreach ($this->selectClassImplements($this->getProviderClasses(), $interfaceName) as $providerClass) {
144		/** @var ProvidesRouteConfiguratorsInterface $providerClass */
145	7	foreach ($providerClass::getRouteConfigurators() as $routesConfClass) {
146		/** @var RoutesConfiguratorInterface $routesConfClass */
147	7	$routesConfClass::configureRoutes($group);
148		}
149		}
150
151	7	return $group;
152		}
153
154		/**
155		* @return Generator
156		*/
157	7	protected function getGlobalMiddleWareHandlers(): Generator
158		{
159		// select global middleware from routes
160	7	foreach ($this->selectClasses($this->getRoutesPath(), RoutesConfiguratorInterface::class) as $selectClass) {
161		/** @var RoutesConfiguratorInterface $selectClass */
162	7	foreach ($selectClass::getMiddleware() as $middlewareClass) {
163	7	$handler = [$middlewareClass, MiddlewareInterface::MIDDLEWARE_METHOD_NAME];
164	7	yield $handler;
165		}
166		}
167
168		// select global middleware from providers
169	7	$interfaceName = ProvidesMiddlewareInterface::class;
170	7	foreach ($this->selectClassImplements($this->getProviderClasses(), $interfaceName) as $providerClass) {
171		/** @var ProvidesMiddlewareInterface $providerClass */
172	7	foreach ($providerClass::getMiddleware() as $middlewareClass) {
173	7	$handler = [$middlewareClass, MiddlewareInterface::MIDDLEWARE_METHOD_NAME];
174	7	yield $handler;
175		}
176		}
177		}
178
179		/**
180		* @return GroupInterface
181		*/
182	7	protected function createGroup(): GroupInterface
183		{
184	7	return new Group();
185		}
186
187		/**
188		* @param string $generatorClass
189		* @param string $dispatcherClass
190		*
191		* @return RouterInterface
192		*/
193	7	protected function createRouter(string $generatorClass, string $dispatcherClass): RouterInterface
194		{
195	7	return new Router($generatorClass, $dispatcherClass);
196		}
197
198		/**
199		* @return string
200		*/
201	7	protected function getConfiguratorsPath(): string
202		{
203	7	return $this->configuratorsPath;
204		}
205
206		/**
207		* @return string[]
208		*/
209	7	protected function getProviderClasses(): array
210		{
211	7	return $this->providerClasses;
212		}
213
214		/**
215		* @return string
216		*/
217	7	protected function getRoutesPath(): string
218		{
219	7	return $this->routesPath;
220		}
221
222		/**
223		* @param string\|array\|callable $mightBeConfigurator
224		*
225		* @return bool
226		*/
227	7	private function isValidContainerConfigurator($mightBeConfigurator): bool
228		{
229	7	return $this->checkPublicStaticCallable($mightBeConfigurator, [ContainerInterface::class]);
230		}
231		}
232

limoncello-php-dist / application

Push — master ( 146147...1776d4 )

CoreData::addRoutes() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like