SymfonyUrlProvider::getCollection() - Code Metrics - Inspection of "Merge pull request #16 from larriereguichet/depend..." - larriereguichet/colonel-smoker-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 96623c...30dc72 )

by Arnaud

created 2020-06-15 12:26 UTC

SymfonyUrlProvider::getCollection() B

↳ Parent: SymfonyUrlProvider

Complexity

Conditions	6
Paths	4

Size

Total Lines	38
Code Lines	20

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	6.0359

Importance

Changes

Metric	Value
cc	6
eloc	20
nc	4
nop	1
dl	0
loc	38
ccs	18
cts	20
cp	0.9
crap	6.0359
rs	8.9777
c	0
b	0
f	0

<?php

namespace LAG\SmokerBundle\Url\Provider;

use Generator;
use LAG\SmokerBundle\Contracts\Url\Provider\UrlProviderInterface;
use LAG\SmokerBundle\Exception\Exception;
use LAG\SmokerBundle\Url\Collection\UrlCollection;
use LAG\SmokerBundle\Url\Requirements\Registry\RequirementsProviderRegistry;
use LAG\SmokerBundle\Url\Url;
use LAG\SmokerBundle\Url\UrlInfo;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\Routing\Exception\MethodNotAllowedException;
use Symfony\Component\Routing\Exception\NoConfigurationException;
use Symfony\Component\Routing\Exception\ResourceNotFoundException;
use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\Router;
use Symfony\Component\Routing\RouterInterface;

class SymfonyUrlProvider implements UrlProviderInterface
{
    /**
     * @var RouterInterface
     */
    protected $router;

    /**
     * @var RequirementsProviderRegistry
     */
    protected $requirementsProviderRegistry;

    /**
     * @var array
     */
    protected $routes;

    /**
     * @var array
     */
    protected $mapping;

    /**
     * @var array
     */
    protected $routingConfiguration;

    /**
     * SymfonyRoutingProvider constructor.
     */
    public function __construct(
        array $routingConfiguration,
        array $routes,
        array $mapping,
        RouterInterface $router,
        RequirementsProviderRegistry $requirementsProviderRegistry
    ) {
        $this->router = $router;
        $this->requirementsProviderRegistry = $requirementsProviderRegistry;
        $this->routes = $routes;
        $this->mapping = $mapping;
        $this->routingConfiguration = $routingConfiguration;
    }

    /**
     * {@inheritdoc}
     */
    public function getName(): string
    {
        return 'symfony';
    }

    /**
     * {@inheritdoc}
     */
    public function supports(string $url): bool
    {
        $urlParts = parse_url($url);

        if (!is_array($urlParts) || !key_exists('path', $urlParts)) {

            return false;
        }
        $path = $urlParts['path'];

        try {
            $this->router->match($path);
        } catch (NoConfigurationException $exception) {
            return false;
        } catch (ResourceNotFoundException $exception) {
            return false;
        } catch (MethodNotAllowedException $exception) {
            return false;
        }

        return true;
    }

    /**
     * {@inheritdoc}
     */
    public function match(string $url): UrlInfo
    {
        $urlParts = parse_url($url);

        if (!is_array($urlParts) || !key_exists('path', $urlParts)) {

            throw new Exception('Can not extract the path from the url "'.$url.'"');
        }
        $path = $urlParts['path'];
        $routingInfo = $this->router->match($path);

        $resolver = new OptionsResolver();
        $resolver
            ->setDefaults([
                'scheme' => '',
                'host' => '',
                'port' => 80,
                'path' => '',
                'query' => '',
                'fragment' => '',
            ])
        ;
        $urlParts = $resolver->resolve($urlParts);

        $urlInfo = new UrlInfo(
            $urlParts['scheme'],
            $urlParts['host'],
            (int) $urlParts['port'],
            $urlParts['path'],
            $urlParts['query'],
            $urlParts['fragment'],
            $routingInfo['_route'],
            $routingInfo
        );

        return $urlInfo;
    }

    /**
     * {@inheritdoc}
     */
    public function configure(OptionsResolver $resolver): void
    {
    }

    /**
     * {@inheritdoc}
     */
    public function getCollection(array $options = []): UrlCollection
    {
        $collection = new UrlCollection();
        $routes = $this->router->getRouteCollection()->all();
        $this->defineContext();

        foreach ($this->routes as $routeName => $routeOptions) {
            // The provided routes should be present in the Symfony routing
            if (!key_exists($routeName, $routes)) {
                continue;
            }
            $route = $routes[$routeName];

            // Two cases: if the route is dynamic, we should generate an url for each requirements provided by
            // requirements providers. If the route is static, one url is generated
            if ($this->hasRouteRequirements($route)) {
                $routeParametersCollection = $this->getRouteRequirements($routeName);

                foreach ($routeParametersCollection as $routeParameters) {
                    $urlParameters = [];

                    if (key_exists('_identifiers', $routeParameters)) {
                        $urlParameters['identifiers'] = $routeParameters['_identifiers'];
                        unset($routeParameters['_identifiers']);
                    }
                    // Use the absolute url parameters to preserve the route configuration, especially if an host is
                    // configured in the Symfony routing
                    $url = $this->router->generate($routeName, $routeParameters, Router::ABSOLUTE_URL);

                    $collection->add(new Url($url, $this->getName(), $urlParameters));
                }
            } else {
                $url = $this->router->generate($routeName, [], Router::ABSOLUTE_URL);
                $collection->add(new Url($url, $this->getName()));
            }
        }

        return $collection;
    }

    /**
     * Return a generator containing each set of parameters according to the providers.
     */
    protected function getRouteRequirements(string $routeName): Generator
    {
        foreach ($this->requirementsProviderRegistry->all() as $requirementsProvider) {
            if (!$requirementsProvider->supports($routeName)) {
                continue;
            }
            $requirements = $requirementsProvider->getRequirementsData($routeName);

            foreach ($requirements as $values) {
                $routeParameters = [];

                foreach ($values as $name => $value) {
                    $routeParameters[$name] = $value;
                }
                yield $routeParameters;
            }
        }
    }

    /**
     * Return true if the given route requires parameters to be generated.
     */
    protected function hasRouteRequirements(Route $route): bool
    {
        if (0 < count($route->getRequirements())) {
            return true;
        }

        if (preg_match('/\{(.*?)\}/', $route->getPath())) {
            return true;
        }

        return false;
    }

    protected function defineContext(): void
    {
        $context = $this->router->getContext();
        $context->setScheme($this->routingConfiguration['scheme']);
        $context->setHost($this->routingConfiguration['host']);
        $context->setBaseUrl($this->routingConfiguration['base_url']);

        if ('https' === $context->getScheme()) {
            $context->setHttpsPort($this->routingConfiguration['port']);
        } else {
            $context->setHttpPort($this->routingConfiguration['port']);
        }
    }
}


1		<?php
2
3		namespace LAG\SmokerBundle\Url\Provider;
4
5		use Generator;
6		use LAG\SmokerBundle\Contracts\Url\Provider\UrlProviderInterface;
7		use LAG\SmokerBundle\Exception\Exception;
8		use LAG\SmokerBundle\Url\Collection\UrlCollection;
9		use LAG\SmokerBundle\Url\Requirements\Registry\RequirementsProviderRegistry;
10		use LAG\SmokerBundle\Url\Url;
11		use LAG\SmokerBundle\Url\UrlInfo;
12		use Symfony\Component\OptionsResolver\OptionsResolver;
13		use Symfony\Component\Routing\Exception\MethodNotAllowedException;
14		use Symfony\Component\Routing\Exception\NoConfigurationException;
15		use Symfony\Component\Routing\Exception\ResourceNotFoundException;
16		use Symfony\Component\Routing\Route;
17		use Symfony\Component\Routing\Router;
18		use Symfony\Component\Routing\RouterInterface;
19
20		class SymfonyUrlProvider implements UrlProviderInterface
21		{
22		/**
23		* @var RouterInterface
24		*/
25		protected $router;
26
27		/**
28		* @var RequirementsProviderRegistry
29		*/
30		protected $requirementsProviderRegistry;
31
32		/**
33		* @var array
34		*/
35		protected $routes;
36
37		/**
38		* @var array
39		*/
40		protected $mapping;
41
42		/**
43		* @var array
44		*/
45		protected $routingConfiguration;
46
47		/**
48		* SymfonyRoutingProvider constructor.
49		*/
50	8	public function __construct(
51		array $routingConfiguration,
52		array $routes,
53		array $mapping,
54		RouterInterface $router,
55		RequirementsProviderRegistry $requirementsProviderRegistry
56		) {
57	8	$this->router = $router;
58	8	$this->requirementsProviderRegistry = $requirementsProviderRegistry;
59	8	$this->routes = $routes;
60	8	$this->mapping = $mapping;
61	8	$this->routingConfiguration = $routingConfiguration;
62	8	}
63
64		/**
65		* {@inheritdoc}
66		*/
67	2	public function getName(): string
68		{
69	2	return 'symfony';
70		}
71
72		/**
73		* {@inheritdoc}
74		*/
75	4	public function supports(string $url): bool
76		{
77	4	$urlParts = parse_url($url);
78
79	4	if (!is_array($urlParts) \|\| !key_exists('path', $urlParts)) {
		0 ignored issues – show introduced 2019-04-03 17:38 UTC by Report Bug Copy Issue Report The condition `is_array($urlParts)` is always `true`. Loading history...
80		return false;
81		}
82	4	$path = $urlParts['path'];
83
84		try {
85	4	$this->router->match($path);
86	3	} catch (NoConfigurationException $exception) {
87	1	return false;
88	2	} catch (ResourceNotFoundException $exception) {
89	1	return false;
90	1	} catch (MethodNotAllowedException $exception) {
91	1	return false;
92		}
93
94	1	return true;
95		}
96
97		/**
98		* {@inheritdoc}
99		*/
100	1	public function match(string $url): UrlInfo
101		{
102	1	$urlParts = parse_url($url);
103
104	1	if (!is_array($urlParts) \|\| !key_exists('path', $urlParts)) {
		0 ignored issues – show introduced 2019-04-03 17:38 UTC by Report Bug Copy Issue Report The condition `is_array($urlParts)` is always `true`. Loading history...
105		throw new Exception('Can not extract the path from the url "'.$url.'"');
106		}
107	1	$path = $urlParts['path'];
108	1	$routingInfo = $this->router->match($path);
109
110	1	$resolver = new OptionsResolver();
111		$resolver
112	1	->setDefaults([
113	1	'scheme' => '',
114		'host' => '',
115		'port' => 80,
116		'path' => '',
117		'query' => '',
118		'fragment' => '',
119		])
120		;
121	1	$urlParts = $resolver->resolve($urlParts);
122
123	1	$urlInfo = new UrlInfo(
124	1	$urlParts['scheme'],
125	1	$urlParts['host'],
126	1	(int) $urlParts['port'],
127	1	$urlParts['path'],
128	1	$urlParts['query'],
129	1	$urlParts['fragment'],
130	1	$routingInfo['_route'],
131		$routingInfo
132		);
133
134	1	return $urlInfo;
135		}
136
137		/**
138		* {@inheritdoc}
139		*/
140	1	public function configure(OptionsResolver $resolver): void
141		{
142	1	}
143
144		/**
145		* {@inheritdoc}
146		*/
147	2	public function getCollection(array $options = []): UrlCollection
148		{
149	2	$collection = new UrlCollection();
150	2	$routes = $this->router->getRouteCollection()->all();
151	2	$this->defineContext();
152
153	2	foreach ($this->routes as $routeName => $routeOptions) {
154		// The provided routes should be present in the Symfony routing
155	2	if (!key_exists($routeName, $routes)) {
156	2	continue;
157		}
158	2	$route = $routes[$routeName];
159
160		// Two cases: if the route is dynamic, we should generate an url for each requirements provided by
161		// requirements providers. If the route is static, one url is generated
162	2	if ($this->hasRouteRequirements($route)) {
163	1	$routeParametersCollection = $this->getRouteRequirements($routeName);
164
165	1	foreach ($routeParametersCollection as $routeParameters) {
166	1	$urlParameters = [];
167
168	1	if (key_exists('_identifiers', $routeParameters)) {
169		$urlParameters['identifiers'] = $routeParameters['_identifiers'];
170		unset($routeParameters['_identifiers']);
171		}
172		// Use the absolute url parameters to preserve the route configuration, especially if an host is
173		// configured in the Symfony routing
174	1	$url = $this->router->generate($routeName, $routeParameters, Router::ABSOLUTE_URL);
175
176	1	$collection->add(new Url($url, $this->getName(), $urlParameters));
177		}
178		} else {
179	1	$url = $this->router->generate($routeName, [], Router::ABSOLUTE_URL);
180	1	$collection->add(new Url($url, $this->getName()));
181		}
182		}
183
184	2	return $collection;
185		}
186
187		/**
188		* Return a generator containing each set of parameters according to the providers.
189		*/
190	1	protected function getRouteRequirements(string $routeName): Generator
191		{
192	1	foreach ($this->requirementsProviderRegistry->all() as $requirementsProvider) {
193	1	if (!$requirementsProvider->supports($routeName)) {
194		continue;
195		}
196	1	$requirements = $requirementsProvider->getRequirementsData($routeName);
197
198	1	foreach ($requirements as $values) {
199	1	$routeParameters = [];
200
201	1	foreach ($values as $name => $value) {
202	1	$routeParameters[$name] = $value;
203		}
204	1	yield $routeParameters;
205		}
206		}
207	1	}
208
209		/**
210		* Return true if the given route requires parameters to be generated.
211		*/
212	2	protected function hasRouteRequirements(Route $route): bool
213		{
214	2	if (0 < count($route->getRequirements())) {
215	1	return true;
216		}
217
218	1	if (preg_match('/\{(.*?)\}/', $route->getPath())) {
219		return true;
220		}
221
222	1	return false;
223		}
224
225	2	protected function defineContext(): void
226		{
227	2	$context = $this->router->getContext();
228	2	$context->setScheme($this->routingConfiguration['scheme']);
229	2	$context->setHost($this->routingConfiguration['host']);
230	2	$context->setBaseUrl($this->routingConfiguration['base_url']);
231
232	2	if ('https' === $context->getScheme()) {
233		$context->setHttpsPort($this->routingConfiguration['port']);
234		} else {
235	2	$context->setHttpPort($this->routingConfiguration['port']);
236		}
237	2	}
238		}
239

larriereguichet / colonel-smoker-bundle

Push — master ( 96623c...30dc72 )

SymfonyUrlProvider::getCollection() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like