SensioExtraProvider::getTests() - Code Metrics - yarhon/RouteGuardBundle - Measure and Improve Code Quality continuously with Scrutinizer

SensioExtraProvider::getTests() B
last analyzed 2018-12-01 21:53 UTC

↳ Parent: SensioExtraProvider

Complexity

Conditions	10
Paths	19

Size

Total Lines	56
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	33
CRAP Score	10

Importance

Changes

Metric	Value
eloc	33
dl	0
loc	56
ccs	33
cts	33
cp	1
rs	7.6666
c	0
b	0
f	0
cc	10
nc	19
nop	3
crap	10

How to fix Long Method Complexity

<?php

/*
 *
 * (c) Yaroslav Honcharuk <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Yarhon\RouteGuardBundle\Security\TestProvider;

use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Symfony\Component\Routing\Route;
use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
use Symfony\Component\ExpressionLanguage\SyntaxError;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security as SecurityAnnotation;
use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted as IsGrantedAnnotation;
use Yarhon\RouteGuardBundle\Annotations\ClassMethodAnnotationReaderInterface;
use Yarhon\RouteGuardBundle\Controller\ControllerMetadata;
use Yarhon\RouteGuardBundle\Routing\RequestAttributesFactory;
use Yarhon\RouteGuardBundle\Routing\RouteMetadataFactory;
use Yarhon\RouteGuardBundle\ExpressionLanguage\ExpressionDecorator;
use Yarhon\RouteGuardBundle\ExpressionLanguage\ExpressionAnalyzer;
use Yarhon\RouteGuardBundle\Security\Test\TestBag;
use Yarhon\RouteGuardBundle\Security\Test\SensioExtraTest;
use Yarhon\RouteGuardBundle\Security\Authorization\SensioSecurityExpressionVoter;
use Yarhon\RouteGuardBundle\Exception\LogicException;
use Yarhon\RouteGuardBundle\Exception\InvalidArgumentException;

/**
 * SensioExtraProvider processes Security & IsGranted annotations of Sensio FrameworkExtraBundle.
 *
 * @see https://symfony.com/doc/5.0/bundles/SensioFrameworkExtraBundle/annotations/security.html
 *
 * @author Yaroslav Honcharuk <[email protected]>
 */
class SensioExtraProvider implements ProviderInterface, LoggerAwareInterface
{
    use LoggerAwareTrait;

    /**
     * @var ClassMethodAnnotationReaderInterface
     */
    private $annotationReader;

    /**
     * @var ExpressionLanguage
     */
    private $expressionLanguage;

    /**
     * @var ExpressionAnalyzer
     */
    private $expressionAnalyzer;

    /**
     * @var RequestAttributesFactory
     */
    private $requestAttributesFactory;

    /**
     * @var RouteMetadataFactory
     */
    private $routeMetadataFactory;

    /**
     * @var array
     */
    private $tests = [];

    /**
     * @param ClassMethodAnnotationReaderInterface $annotationReader
     * @param RequestAttributesFactory             $requestAttributesFactory
     * @param RouteMetadataFactory                 $routeMetadataFactory
     */
    public function __construct(ClassMethodAnnotationReaderInterface $annotationReader, RequestAttributesFactory $requestAttributesFactory, RouteMetadataFactory $routeMetadataFactory)
    {
        $this->annotationReader = $annotationReader;
        $this->requestAttributesFactory = $requestAttributesFactory;
        $this->routeMetadataFactory = $routeMetadataFactory;
    }

    /**
     * @param ExpressionLanguage $expressionLanguage
     */
    public function setExpressionLanguage(ExpressionLanguage $expressionLanguage)
    {
        $this->expressionLanguage = $expressionLanguage;
    }

    /**
     * @param ExpressionAnalyzer $expressionAnalyzer
     */
    public function setExpressionAnalyzer($expressionAnalyzer)
    {
        $this->expressionAnalyzer = $expressionAnalyzer;
    }

    /**
     * {@inheritdoc}
     */
    public function getTests($routeName, Route $route, ControllerMetadata $controllerMetadata = null)
    {
        if (!$controllerMetadata) {
            return null;
        }

        $annotations = $this->annotationReader->read($controllerMetadata->getClass(), $controllerMetadata->getMethod(),
            [SecurityAnnotation::class, IsGrantedAnnotation::class]
        );

        if (!count($annotations)) {
            return null;
        }

        $controllerArguments = array_keys($controllerMetadata->getArguments());
        $requestAttributes = $this->getRequestAttributeNames($route);
        $requestAttributes = array_diff($requestAttributes, $controllerArguments);
        $allowedVariables = array_merge($controllerArguments, $requestAttributes);

        $tests = [];

        foreach ($annotations as $annotation) {
            $subjectName = null;

            if ($annotation instanceof SecurityAnnotation) {
                $expression = $this->processSecurityAnnotation($annotation, $allowedVariables);
                $attributes = [$expression];
                $usedVariables = $expression->getVariableNames();
            } elseif ($annotation instanceof IsGrantedAnnotation) {
                list($role, $subjectName) = $this->processIsGrantedAnnotation($annotation, $allowedVariables);
                $attributes = [$role];
                $usedVariables = $subjectName ? [$subjectName] : [];
            }

            if (count($usedVariables)) {

                $test = new SensioExtraTest($attributes, $subjectName);


                $usedRequestAttributes = array_values(array_intersect($usedVariables, $requestAttributes));

                if (count($usedRequestAttributes)) {
                    $test->setMetadata('request_attributes', $usedRequestAttributes);
                }
            } else {
                $uniqueKey = $this->getTestAttributesUniqueKey($attributes);

                if (!isset($this->tests[$uniqueKey])) {
                    $this->tests[$uniqueKey] = new SensioExtraTest($attributes);
                }

                $test = $this->tests[$uniqueKey];
            }

            $tests[] = $test;
        }

        return new TestBag($tests);
    }

    /**
     * @param SecurityAnnotation $annotation
     * @param array              $allowedVariables
     *
     * @return ExpressionDecorator
     */
    private function processSecurityAnnotation(SecurityAnnotation $annotation, array $allowedVariables)
    {
        if (!$this->expressionLanguage) {
            throw new LogicException('Cannot create expression because ExpressionLanguage is not provided.');
        }

        $expression = $annotation->getExpression();

        return $this->createExpression($expression, $allowedVariables);
    }

    /**
     * @param IsGrantedAnnotation $annotation
     * @param array               $allowedVariables
     *
     * @return array
     */
    private function processIsGrantedAnnotation(IsGrantedAnnotation $annotation, array $allowedVariables)
    {
        // Despite of the name, $annotation->getAttributes() is a string (annotation value)
        $role = $annotation->getAttributes();

        $subjectName = $annotation->getSubject() ?: null;

        if (null !== $subjectName && !in_array($subjectName, $allowedVariables, true)) {
            throw new InvalidArgumentException(sprintf('Unknown subject variable "%s". Allowed variables: "%s".', $subjectName, implode('", "', $allowedVariables)));
        }

        return [$role, $subjectName];
    }

    /**
     * @param Route $route
     *
     * @return string[]
     */
    private function getRequestAttributeNames(Route $route)
    {
        $routeMetadata = $this->routeMetadataFactory->createMetadata($route);

        return $this->requestAttributesFactory->getAttributeNames($routeMetadata);
    }

    /**
     * @param string $expression
     * @param array  $allowedVariables
     *
     * @return ExpressionDecorator
     *
     * @throws InvalidArgumentException
     */
    private function createExpression($expression, array $allowedVariables)
    {
        $voterVariableNames = SensioSecurityExpressionVoter::getVariableNames();
        $namesToParse = array_merge($voterVariableNames, $allowedVariables);

        try {
            if (!$this->expressionAnalyzer) {
                try {
                    // At first try to create expression without any variable names to save time during expression resolving
                    $parsed = $this->expressionLanguage->parse($expression, $voterVariableNames);
                    $usedVariables = [];
                } catch (SyntaxError $e) {
                    $parsed = $this->expressionLanguage->parse($expression, $namesToParse);
                    $usedVariables = $allowedVariables;
                }
            } else {
                $parsed = $this->expressionLanguage->parse($expression, $namesToParse);
                $usedVariables = $this->expressionAnalyzer->getUsedVariables($parsed);
                $usedVariables = array_values(array_diff($usedVariables, $voterVariableNames));
            }
        } catch (SyntaxError $e) {
            throw new InvalidArgumentException(sprintf('Cannot parse expression "%s" with following variables: "%s".', $expression, implode('", "', $namesToParse)), 0, $e);
        }

        return new ExpressionDecorator($parsed, $usedVariables);
    }

    /**
     * @param array $attributes
     *
     * @return string
     */
    private function getTestAttributesUniqueKey(array $attributes)
    {
        $roles = $attributes;

        $expressions = array_filter($attributes, function ($attribute) {
            return $attribute instanceof ExpressionDecorator;
        });

        $roles = array_diff($roles, $expressions);

        $expressions = array_map(function ($expression) {
            return (string) $expression;
        }, $expressions);

        $roles = array_unique($roles);
        sort($roles);

        return implode('#', array_merge($roles, $expressions));
    }
}


1		<?php
2
3		/*
4		*
5		* (c) Yaroslav Honcharuk <[email protected]>
6		*
7		* For the full copyright and license information, please view the LICENSE
8		* file that was distributed with this source code.
9		*/
10
11		namespace Yarhon\RouteGuardBundle\Security\TestProvider;
12
13		use Psr\Log\LoggerAwareInterface;
14		use Psr\Log\LoggerAwareTrait;
15		use Symfony\Component\Routing\Route;
16		use Symfony\Component\ExpressionLanguage\ExpressionLanguage;
17		use Symfony\Component\ExpressionLanguage\SyntaxError;
18		use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security as SecurityAnnotation;
19		use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted as IsGrantedAnnotation;
20		use Yarhon\RouteGuardBundle\Annotations\ClassMethodAnnotationReaderInterface;
21		use Yarhon\RouteGuardBundle\Controller\ControllerMetadata;
22		use Yarhon\RouteGuardBundle\Routing\RequestAttributesFactory;
23		use Yarhon\RouteGuardBundle\Routing\RouteMetadataFactory;
24		use Yarhon\RouteGuardBundle\ExpressionLanguage\ExpressionDecorator;
25		use Yarhon\RouteGuardBundle\ExpressionLanguage\ExpressionAnalyzer;
26		use Yarhon\RouteGuardBundle\Security\Test\TestBag;
27		use Yarhon\RouteGuardBundle\Security\Test\SensioExtraTest;
28		use Yarhon\RouteGuardBundle\Security\Authorization\SensioSecurityExpressionVoter;
29		use Yarhon\RouteGuardBundle\Exception\LogicException;
30		use Yarhon\RouteGuardBundle\Exception\InvalidArgumentException;
31
32		/**
33		* SensioExtraProvider processes Security & IsGranted annotations of Sensio FrameworkExtraBundle.
34		*
35		* @see https://symfony.com/doc/5.0/bundles/SensioFrameworkExtraBundle/annotations/security.html
36		*
37		* @author Yaroslav Honcharuk <[email protected]>
38		*/
39		class SensioExtraProvider implements ProviderInterface, LoggerAwareInterface
40		{
41		use LoggerAwareTrait;
42
43		/**
44		* @var ClassMethodAnnotationReaderInterface
45		*/
46		private $annotationReader;
47
48		/**
49		* @var ExpressionLanguage
50		*/
51		private $expressionLanguage;
52
53		/**
54		* @var ExpressionAnalyzer
55		*/
56		private $expressionAnalyzer;
57
58		/**
59		* @var RequestAttributesFactory
60		*/
61		private $requestAttributesFactory;
62
63		/**
64		* @var RouteMetadataFactory
65		*/
66		private $routeMetadataFactory;
67
68		/**
69		* @var array
70		*/
71		private $tests = [];
72
73		/**
74		* @param ClassMethodAnnotationReaderInterface $annotationReader
75		* @param RequestAttributesFactory $requestAttributesFactory
76		* @param RouteMetadataFactory $routeMetadataFactory
77		*/
78	29	public function __construct(ClassMethodAnnotationReaderInterface $annotationReader, RequestAttributesFactory $requestAttributesFactory, RouteMetadataFactory $routeMetadataFactory)
79		{
80	29	$this->annotationReader = $annotationReader;
81	29	$this->requestAttributesFactory = $requestAttributesFactory;
82	29	$this->routeMetadataFactory = $routeMetadataFactory;
83	29	}
84
85		/**
86		* @param ExpressionLanguage $expressionLanguage
87		*/
88	21	public function setExpressionLanguage(ExpressionLanguage $expressionLanguage)
89		{
90	21	$this->expressionLanguage = $expressionLanguage;
91	21	}
92
93		/**
94		* @param ExpressionAnalyzer $expressionAnalyzer
95		*/
96	12	public function setExpressionAnalyzer($expressionAnalyzer)
97		{
98	12	$this->expressionAnalyzer = $expressionAnalyzer;
99	12	}
100
101		/**
102		* {@inheritdoc}
103		*/
104	29	public function getTests($routeName, Route $route, ControllerMetadata $controllerMetadata = null)
105		{
106	29	if (!$controllerMetadata) {
107	1	return null;
108		}
109
110	28	$annotations = $this->annotationReader->read($controllerMetadata->getClass(), $controllerMetadata->getMethod(),
111	28	[SecurityAnnotation::class, IsGrantedAnnotation::class]
112		);
113
114	28	if (!count($annotations)) {
115	11	return null;
116		}
117
118	27	$controllerArguments = array_keys($controllerMetadata->getArguments());
119	27	$requestAttributes = $this->getRequestAttributeNames($route);
120	27	$requestAttributes = array_diff($requestAttributes, $controllerArguments);
121	27	$allowedVariables = array_merge($controllerArguments, $requestAttributes);
122
123	27	$tests = [];
124
125	27	foreach ($annotations as $annotation) {
126	27	$subjectName = null;
127
128	27	if ($annotation instanceof SecurityAnnotation) {
129	19	$expression = $this->processSecurityAnnotation($annotation, $allowedVariables);
130	17	$attributes = [$expression];
131	17	$usedVariables = $expression->getVariableNames();
132	18	} elseif ($annotation instanceof IsGrantedAnnotation) {
133	18	list($role, $subjectName) = $this->processIsGrantedAnnotation($annotation, $allowedVariables);
134	17	$attributes = [$role];
135	17	$usedVariables = $subjectName ? [$subjectName] : [];
136		}
137
138	24	if (count($usedVariables)) {
		0 ignored issues – show Comprehensibility Best Practice introduced 2018-11-08 00:47 UTC by Report Bug Copy Issue Report The variable `$usedVariables` does not seem to be defined for all execution paths leading up to this point. Loading history...
139	17	$test = new SensioExtraTest($attributes, $subjectName);
		0 ignored issues – show Comprehensibility Best Practice introduced 2018-11-10 02:11 UTC by Report Bug Copy Issue Report The variable `$attributes` does not seem to be defined for all execution paths leading up to this point. Loading history...
140
141	17	$usedRequestAttributes = array_values(array_intersect($usedVariables, $requestAttributes));
142
143	17	if (count($usedRequestAttributes)) {
144	2	$test->setMetadata('request_attributes', $usedRequestAttributes);
145		}
146		} else {
147	18	$uniqueKey = $this->getTestAttributesUniqueKey($attributes);
148
149	18	if (!isset($this->tests[$uniqueKey])) {
150	18	$this->tests[$uniqueKey] = new SensioExtraTest($attributes);
151		}
152
153	18	$test = $this->tests[$uniqueKey];
154		}
155
156	24	$tests[] = $test;
157		}
158
159	24	return new TestBag($tests);
160		}
161
162		/**
163		* @param SecurityAnnotation $annotation
164		* @param array $allowedVariables
165		*
166		* @return ExpressionDecorator
167		*/
168	19	private function processSecurityAnnotation(SecurityAnnotation $annotation, array $allowedVariables)
169		{
170	19	if (!$this->expressionLanguage) {
171	1	throw new LogicException('Cannot create expression because ExpressionLanguage is not provided.');
172		}
173
174	18	$expression = $annotation->getExpression();
175
176	18	return $this->createExpression($expression, $allowedVariables);
177		}
178
179		/**
180		* @param IsGrantedAnnotation $annotation
181		* @param array $allowedVariables
182		*
183		* @return array
184		*/
185	18	private function processIsGrantedAnnotation(IsGrantedAnnotation $annotation, array $allowedVariables)
186		{
187		// Despite of the name, $annotation->getAttributes() is a string (annotation value)
188	18	$role = $annotation->getAttributes();
189
190	18	$subjectName = $annotation->getSubject() ?: null;
191
192	18	if (null !== $subjectName && !in_array($subjectName, $allowedVariables, true)) {
193	1	throw new InvalidArgumentException(sprintf('Unknown subject variable "%s". Allowed variables: "%s".', $subjectName, implode('", "', $allowedVariables)));
194		}
195
196	17	return [$role, $subjectName];
197		}
198
199		/**
200		* @param Route $route
201		*
202		* @return string[]
203		*/
204	27	private function getRequestAttributeNames(Route $route)
205		{
206	27	$routeMetadata = $this->routeMetadataFactory->createMetadata($route);
207
208	27	return $this->requestAttributesFactory->getAttributeNames($routeMetadata);
209		}
210
211		/**
212		* @param string $expression
213		* @param array $allowedVariables
214		*
215		* @return ExpressionDecorator
216		*
217		* @throws InvalidArgumentException
218		*/
219	18	private function createExpression($expression, array $allowedVariables)
220		{
221	18	$voterVariableNames = SensioSecurityExpressionVoter::getVariableNames();
222	18	$namesToParse = array_merge($voterVariableNames, $allowedVariables);
223
224		try {
225	18	if (!$this->expressionAnalyzer) {
226		try {
227		// At first try to create expression without any variable names to save time during expression resolving
228	6	$parsed = $this->expressionLanguage->parse($expression, $voterVariableNames);
229	2	$usedVariables = [];
230	4	} catch (SyntaxError $e) {
231	4	$parsed = $this->expressionLanguage->parse($expression, $namesToParse);
232	3	$usedVariables = $allowedVariables;
233		}
234		} else {
235	12	$parsed = $this->expressionLanguage->parse($expression, $namesToParse);
236	12	$usedVariables = $this->expressionAnalyzer->getUsedVariables($parsed);
237	12	$usedVariables = array_values(array_diff($usedVariables, $voterVariableNames));
238		}
239	1	} catch (SyntaxError $e) {
240	1	throw new InvalidArgumentException(sprintf('Cannot parse expression "%s" with following variables: "%s".', $expression, implode('", "', $namesToParse)), 0, $e);
241		}
242
243	17	return new ExpressionDecorator($parsed, $usedVariables);
244		}
245
246		/**
247		* @param array $attributes
248		*
249		* @return string
250		*/
251	18	private function getTestAttributesUniqueKey(array $attributes)
252		{
253	18	$roles = $attributes;
254
255		$expressions = array_filter($attributes, function ($attribute) {
256	18	return $attribute instanceof ExpressionDecorator;
257	18	});
258
259	18	$roles = array_diff($roles, $expressions);
260
261		$expressions = array_map(function ($expression) {
262	14	return (string) $expression;
263	18	}, $expressions);
264
265	18	$roles = array_unique($roles);
266	18	sort($roles);
267
268	18	return implode('#', array_merge($roles, $expressions));
269		}
270		}
271

yarhon / RouteGuardBundle

SensioExtraProvider::getTests() B last analyzed 2018-12-01 21:53 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Complexity

Long Method

Duplication Side-by-Side

Filter issues like

SensioExtraProvider::getTests() B
last analyzed 2018-12-01 21:53 UTC