Composite::ensureRules() - Code Metrics - Inspection of "[WIP] Psr12" - ROAResearch/yii2-roa - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#2)

by Angel

created 2019-11-28 17:37 UTC

Composite::ensureRules() A

↳ Parent: Composite

Complexity

Conditions	2
Paths	2

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	6
rs	10
c	0
b	0
f	0
cc	2
nc	2
nop	0

<?php

namespace roaresearch\yii2\roa\urlRules;

use Yii;
use yii\{
    base\InvalidConfigException,
    web\NotFoundHttpException,
    web\UrlManager,
    web\UrlNormalizer
};

/**
 * Url rule that can call children rule when applicable.
 *
 * @author Angel (Faryshta) Guevara <[email protected]>
 */
abstract class Composite extends \yii\web\CompositeUrlRule
{
    /**
     * @var bool whether this rule must throw an `NotFoundHttpException` when
     * parse request fails.
     */
    public $strict = true;

    /**
     * @var UrlNormalizer|null
     */
    public $normalizer = null;

    /**
     * @var string message used to create the `NotFoundHttpException` when
     * `$strict` equals `true` and no children rules could parse the request.
     */
    public $notFoundMessage = 'Unknown route.';

    /**
     * @inheritdoc
     */
    public function init()
    {
        if (is_array($this->normalizer)) {
            $this->normalizer = Yii::createObject(array_merge(
                ['class' => UrlNormalizer::class],
                $this->normalizer
            ));
        }
        if (!empty($this->normalizer)
            && !$this->normalizer instanceof UrlNormalizer
        ) {
            throw new InvalidConfigException(
                'Invalid config for `normalizer`.'
            );
        }
    }

    /**
     * Determines if this rule must parse the request using the children rules
     * or return `false` inmediately.
     *
     * @param string $route
     * @return bool
     */
    abstract protected function isApplicable(string $route): bool;

    /**
     * Ensures that `$rules` property is set
     */
    private function ensureRules()
    {
        if (empty($this->rules)) {
            $this->rules = $this->createRules();
        }
    }

    /**
     * @inheritdoc
     */
    public function parseRequest($manager, $request)
    {
        // only parse rules applicable rules
        if (!$this->isApplicable($request->pathInfo)) {
            return false;
        }
        $normalized = false;
        if ($this->hasNormalizer($manager)) {
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
            $request->pathInfo = $this->getNormalizer($manager)
                ->normalizePathInfo(
                    $request->pathInfo,
                    '',
                    $normalized
                );
        }
        $this->ensureRules();
        $result = parent::parseRequest($manager, $request);
        if ($result === false && $this->strict === true) {
            throw $this->createNotFoundException();
        }

        return $normalized
            ? $this->getNormalizer($manager)->normalizeRoute($result)
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            : $result;
    }

    /**
     * @inheritdoc
     */
    public function createUrl($manager, $route, $params)
    {
        // only parse rules applicable rules
        if (!$this->isApplicable($route)) {
            return false;
        }
        $this->ensureRules();

        return parent::createUrl($manager, $route, $params);
    }

    /**
     * @param UrlManager $manager the URL manager
     * @return bool
     */
    protected function hasNormalizer($manager): bool
    {
        return null !== $this->getNormalizer($manager);
    }

    /**
     * @param UrlManager $manager the URL manager

     * @return ?UrlNormalizer

     */
    protected function getNormalizer(UrlManager $manager): ?UrlNormalizer
    {
        if ($this->normalizer === null
            && $manager->normalizer instanceof UrlNormalizer
        ) {
            return $manager->normalizer;
        }

        return $this->normalizer;
    }

    /**
     * @return NotFoundHttpException

     */
    protected function createNotFoundException(): NotFoundHttpException
    {
        return new NotFoundHttpException($this->notFoundMessage);
    }
}


1			<?php
2
3			namespace roaresearch\yii2\roa\urlRules;
4
5			use Yii;
6			use yii\{
7			base\InvalidConfigException,
8			web\NotFoundHttpException,
9			web\UrlManager,
10			web\UrlNormalizer
11			};
12
13			/**
14			* Url rule that can call children rule when applicable.
15			*
16			* @author Angel (Faryshta) Guevara <[email protected]>
17			*/
18			abstract class Composite extends \yii\web\CompositeUrlRule
19			{
20			/**
21			* @var bool whether this rule must throw an `NotFoundHttpException` when
22			* parse request fails.
23			*/
24			public $strict = true;
25
26			/**
27			* @var UrlNormalizer\|null
28			*/
29			public $normalizer = null;
30
31			/**
32			* @var string message used to create the `NotFoundHttpException` when
33			* `$strict` equals `true` and no children rules could parse the request.
34			*/
35			public $notFoundMessage = 'Unknown route.';
36
37			/**
38			* @inheritdoc
39			*/
40			public function init()
41			{
42			if (is_array($this->normalizer)) {
43			$this->normalizer = Yii::createObject(array_merge(
44			['class' => UrlNormalizer::class],
45			$this->normalizer
46			));
47			}
48			if (!empty($this->normalizer)
49			&& !$this->normalizer instanceof UrlNormalizer
50			) {
51			throw new InvalidConfigException(
52			'Invalid config for `normalizer`.'
53			);
54			}
55			}
56
57			/**
58			* Determines if this rule must parse the request using the children rules
59			* or return `false` inmediately.
60			*
61			* @param string $route
62			* @return bool
63			*/
64			abstract protected function isApplicable(string $route): bool;
65
66			/**
67			* Ensures that `$rules` property is set
68			*/
69			private function ensureRules()
70			{
71			if (empty($this->rules)) {
72			$this->rules = $this->createRules();
73			}
74			}
75
76			/**
77			* @inheritdoc
78			*/
79			public function parseRequest($manager, $request)
80			{
81			// only parse rules applicable rules
82			if (!$this->isApplicable($request->pathInfo)) {
83			return false;
84			}
85			$normalized = false;
86			if ($this->hasNormalizer($manager)) {
			0 ignored issues – show Documentation introduced 2019-11-09 08:59 UTC by Report Bug Copy Issue Report `$manager` is of type `object<yii\web\UrlManager>`, but the function expects a `object<web\UrlManager>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
87			$request->pathInfo = $this->getNormalizer($manager)
88			->normalizePathInfo(
89			$request->pathInfo,
90			'',
91			$normalized
92			);
93			}
94			$this->ensureRules();
95			$result = parent::parseRequest($manager, $request);
96			if ($result === false && $this->strict === true) {
97			throw $this->createNotFoundException();
98			}
99
100			return $normalized
101			? $this->getNormalizer($manager)->normalizeRoute($result)
			0 ignored issues – show Bug introduced 2019-11-09 03:27 UTC by Report Bug Copy Issue Report It seems like `$result` defined by `parent::parseRequest($manager, $request)` on line `95` can also be of type `boolean`; however, `yii\web\UrlNormalizer::normalizeRoute()` does only seem to accept `array`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
102			: $result;
103			}
104
105			/**
106			* @inheritdoc
107			*/
108			public function createUrl($manager, $route, $params)
109			{
110			// only parse rules applicable rules
111			if (!$this->isApplicable($route)) {
112			return false;
113			}
114			$this->ensureRules();
115
116			return parent::createUrl($manager, $route, $params);
117			}
118
119			/**
120			* @param UrlManager $manager the URL manager
121			* @return bool
122			*/
123			protected function hasNormalizer($manager): bool
124			{
125			return null !== $this->getNormalizer($manager);
126			}
127
128			/**
129			* @param UrlManager $manager the URL manager
			0 ignored issues – show Documentation introduced 2019-11-09 08:59 UTC by Report Bug Copy Issue Report Should the type for parameter `$manager` not be `\yii\web\UrlManager`? This check looks for `@param` annotations where the type inferred by our type inference engine differs from the declared type. It makes a suggestion as to what type it considers more descriptive. Most often this is a case of a parameter that can be null in addition to its declared types. Loading history...
130			* @return ?UrlNormalizer
			0 ignored issues – show Documentation introduced 2019-11-09 03:27 UTC by Report Bug Copy Issue Report The doc-type `?UrlNormalizer` could not be parsed: Unknown type name "?UrlNormalizer" at position 0. (view supported doc-types) This check marks PHPDoc comments that could not be parsed by our parser. To see which comment annotations we can parse, please refer to our documentation on supported doc-types. Loading history...
131			*/
132			protected function getNormalizer(UrlManager $manager): ?UrlNormalizer
133			{
134			if ($this->normalizer === null
135			&& $manager->normalizer instanceof UrlNormalizer
136			) {
137			return $manager->normalizer;
138			}
139
140			return $this->normalizer;
141			}
142
143			/**
144			* @return NotFoundHttpException
			0 ignored issues – show Documentation introduced 2019-11-09 08:59 UTC by Report Bug Copy Issue Report Should the return type not be `\yii\web\NotFoundHttpException`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
145			*/
146			protected function createNotFoundException(): NotFoundHttpException
147			{
148			return new NotFoundHttpException($this->notFoundMessage);
149			}
150			}
151

ROAResearch / yii2-roa

Pull Request — master (#2)

Composite::ensureRules() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like