Biurad\DependencyInjection\Exceptions\ParameterNotFoundException

Complexity

Total Complexity

6

Size/Duplication

Total Lines	53
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	updateRepr()	0	14	4
A	__construct()	0	13	1
A	getKey()	0	3	1

<?php

declare(strict_types=1);

/*
 * This file is part of Biurad opensource projects.
 *
 * PHP version 7.2 and above required
 *
 * @author    Divine Niiquaye Ibok <divineibok@gmail.com>
 * @copyright 2019 Biurad Group (https://biurad.com/)
 * @license   https://opensource.org/licenses/BSD-3-Clause License
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Biurad\DependencyInjection\Exceptions;

use InvalidArgumentException;
use Psr\Container\NotFoundExceptionInterface;
use Throwable;

/**
 * This exception is thrown when a non-existent parameter is used.
 *
 * @author Fabien Potencier <fabien@symfony.com>
 */
class ParameterNotFoundException extends InvalidArgumentException implements NotFoundExceptionInterface
{
    /** @var string */
    private $key;

    /** @var array */
    private $alternatives;

    /** @var array */
    private $nonNestedAlternative;

    /**
     * @param string      $key                  The requested parameter key
     * @param Throwable   $previous             The previous exception
     * @param string[]    $alternatives         Some parameter name alternatives
     * @param null|string $nonNestedAlternative The alternative parameter name when the user
     *                                          expected dot notation for nested parameters
     */
    public function __construct(
        string $key,
        Throwable $previous = null,
        array $alternatives = [],
        string $nonNestedAlternative = null
    ) {
        $this->key                  = $key;
        $this->alternatives         = $alternatives;
        $this->nonNestedAlternative = $nonNestedAlternative;

It seems like $nonNestedAlternative can also be of type string. However, the property $nonNestedAlternative is declared as type array. Maybe add an additional type check?

        parent::__construct('', 0, $previous);

        $this->updateRepr();
    }

    public function updateRepr(): void
    {
        $this->message = \sprintf('You have requested a non-existent parameter "%s".', $this->key);

        if ($this->alternatives) {

The expression $this->alternatives of type array is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            if (1 == \count($this->alternatives)) {
                $this->message .= ' Did you mean this: "';
            } else {
                $this->message .= ' Did you mean one of these: "';
            }
            $this->message .= \implode('", "', $this->alternatives) . '"?';
        } elseif (null !== $this->nonNestedAlternative) {
            $this->message .= ' You cannot access nested array items, do you want to inject "' .
            $this->nonNestedAlternative . '" instead?';

Are you sure $this->nonNestedAlternative of type array can be used in concatenation?

        }
    }

    public function getKey()
    {
        return $this->key;
    }
}