roaresearch\yii2\roa\urlRules\Composite

Complexity

Total Complexity

19

Size/Duplication

Total Lines	133
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	init()	0	16	4
	isApplicable()	0	1	?
A	ensureRules()	0	6	2
B	parseRequest()	0	25	6
A	createUrl()	0	10	2
A	hasNormalizer()	0	4	1
A	getNormalizer()	0	10	3
A	createNotFoundException()	0	4	1

<?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 <aguevara@alquimiadigital.mx>
 */
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)) {

$manager is of type object<yii\web\UrlManager>, but the function expects a object<web\UrlManager>.

            $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)

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?

            : $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

Should the type for parameter $manager not be \yii\web\UrlManager?

     * @return ?UrlNormalizer

The doc-type ?UrlNormalizer could not be parsed: Unknown type name "?UrlNormalizer" at position 0. (view supported doc-types)

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

        return $this->normalizer;
    }

    /**
     * @return NotFoundHttpException

Should the return type not be \yii\web\NotFoundHttpException?

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