Compare::__construct() - Code Metrics - Inspection of "[Coverage] Rules" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#369)

unknown

created 2022-11-15 08:38 UTC

Compare::__construct() A

↳ Parent: Compare

Complexity

Conditions	2
Paths	2

Size

Total Lines	58
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	8
c	1
b	0
f	0
dl	0
loc	58
ccs	7
cts	7
cp	1
rs	10
cc	2
nc	2
nop	10
crap	2

How to fix Long Method Many Parameters

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule;

use Closure;
use InvalidArgumentException;
use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
use Yiisoft\Validator\Rule\Trait\SkipOnErrorTrait;
use Yiisoft\Validator\Rule\Trait\WhenTrait;
use Yiisoft\Validator\SerializableRuleInterface;
use Yiisoft\Validator\SkipOnEmptyInterface;
use Yiisoft\Validator\SkipOnErrorInterface;
use Yiisoft\Validator\ValidationContext;
use Yiisoft\Validator\WhenInterface;

abstract class Compare implements SerializableRuleInterface, SkipOnEmptyInterface, SkipOnErrorInterface, WhenInterface
{
    use SkipOnEmptyTrait;
    use SkipOnErrorTrait;
    use WhenTrait;

    /**
     * Constant for specifying the comparison as string values.
     * Values will be converted to strings before comparison.
     *
     * @see $type
     */
    public const TYPE_STRING = 'string';
    /**
     * Constant for specifying the comparison as numeric values.
     * Values will be converted to float numbers before comparison.
     *
     * @see $type
     */
    public const TYPE_NUMBER = 'number';

    private array $validOperatorsMap = [
        '==' => 1,
        '===' => 1,
        '!=' => 1,
        '!==' => 1,
        '>' => 1,
        '>=' => 1,
        '<' => 1,
        '<=' => 1,
    ];

    public function __construct(
        /**
         * @var scalar|null The constant value to be compared with. When both this property and {@see $targetAttribute}
         * are set, this property takes precedence.
         */
        private int|float|string|bool|null $targetValue = null,
        /**
         * @var string|null The name of the attribute to be compared with. When both this property and
         * {@see $targetValue} are set, the {@see $targetValue} takes precedence.
         */
        private string|null $targetAttribute = null,
        private string $incorrectInputMessage = 'The allowed types are integer, float, string, boolean and null.',
        private string $incorrectDataSetTypeMessage = 'The attribute value returned from a custom data set must have ' .
        'a scalar type.',
        /**
         * @var string|null User-defined error message.
         */
        private string|null $message = null,
        /**
         * @var string The type of the values being compared.
         */
        private string $type = self::TYPE_STRING,
        /**
         * @var string The operator for comparison. The following operators are supported:
         *
         * - `==`: check if two values are equal. The comparison is done in non-strict mode.
         * - `===`: check if two values are equal. The comparison is done in strict mode.
         * - `!=`: check if two values are NOT equal. The comparison is done in non-strict mode.
         * - `!==`: check if two values are NOT equal. The comparison is done in strict mode.
         * - `>`: check if value being validated is greater than the value being compared with.
         * - `>=`: check if value being validated is greater than or equal to the value being compared with.
         * - `<`: check if value being validated is less than the value being compared with.
         * - `<=`: check if value being validated is less than or equal to the value being compared with.
         *
         * When you want to compare numbers, make sure to also change {@see $type} to {@see TYPE_NUMBER}.
         */
        private string $operator = '==',
        /**
         * @var bool|callable|null
         */
        private mixed $skipOnEmpty = null,
        private bool $skipOnError = false,
        /**
         * @var Closure(mixed, ValidationContext):bool|null
         */
        private ?Closure $when = null,
    ) {
        if (!isset($this->validOperatorsMap[$this->operator])) {
            $validOperatorsString = implode(
                ', ',
                array_map(
                    static fn (string $operator): string => '"' . $operator . '"',
                    array_keys($this->validOperatorsMap),
                ),
            );
            $message = "Operator \"$operator\" is not supported. The valid operators are: $validOperatorsString.";

            throw new InvalidArgumentException($message);
        }
    }

    /**
     * @return scalar|null
     */
    public function getTargetValue(): int|float|string|bool|null
    {
        return $this->targetValue;
    }

    public function getTargetAttribute(): string|null
    {
        return $this->targetAttribute;
    }

    public function getType(): string
    {
        return $this->type;
    }

    public function getOperator(): string
    {
        return $this->operator;
    }

    public function getIncorrectInputMessage(): string
    {
        return $this->incorrectInputMessage;
    }

    public function getIncorrectDataSetTypeMessage(): string
    {
        return $this->incorrectDataSetTypeMessage;
    }

    public function getMessage(): string
    {
        return $this->message ?? match ($this->operator) {
            '==', '===' => 'Value must be equal to "{targetValueOrAttribute}".',
            '!=', '!==' => 'Value must not be equal to "{targetValueOrAttribute}".',
            '>' => 'Value must be greater than "{targetValueOrAttribute}".',
            '>=' => 'Value must be greater than or equal to "{targetValueOrAttribute}".',
            '<' => 'Value must be less than "{targetValueOrAttribute}".',
            '<=' => 'Value must be less than or equal to "{targetValueOrAttribute}".',
        };
    }

    public function getOptions(): array
    {
        $messageParameters = [
            'targetValue' => $this->targetValue,
            'targetAttribute' => $this->targetAttribute,
            'targetValueOrAttribute' => $this->targetValue ?? $this->targetAttribute,
        ];

        return [
            'targetValue' => $this->targetValue,
            'targetAttribute' => $this->targetAttribute,
            'incorrectInputMessage' => [
                'message' => $this->incorrectInputMessage,
                'parameters' => $messageParameters,
            ],
            'incorrectDataSetTypeMessage' => [
                'message' => $this->incorrectDataSetTypeMessage,
                'parameters' => $messageParameters,
            ],
            'message' => [
                'message' => $this->getMessage(),
                'parameters' => $messageParameters,
            ],
            'type' => $this->type,
            'operator' => $this->operator,
            'skipOnEmpty' => $this->getSkipOnEmptyOption(),
            'skipOnError' => $this->skipOnError,
        ];
    }

    public function getHandlerClassName(): string
    {
        return CompareHandler::class;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Validator\Rule;
6
7		use Closure;
8		use InvalidArgumentException;
9		use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
10		use Yiisoft\Validator\Rule\Trait\SkipOnErrorTrait;
11		use Yiisoft\Validator\Rule\Trait\WhenTrait;
12		use Yiisoft\Validator\SerializableRuleInterface;
13		use Yiisoft\Validator\SkipOnEmptyInterface;
14		use Yiisoft\Validator\SkipOnErrorInterface;
15		use Yiisoft\Validator\ValidationContext;
16		use Yiisoft\Validator\WhenInterface;
17
18		abstract class Compare implements SerializableRuleInterface, SkipOnEmptyInterface, SkipOnErrorInterface, WhenInterface
19		{
20		use SkipOnEmptyTrait;
21		use SkipOnErrorTrait;
22		use WhenTrait;
23
24		/**
25		* Constant for specifying the comparison as string values.
26		* Values will be converted to strings before comparison.
27		*
28		* @see $type
29		*/
30		public const TYPE_STRING = 'string';
31		/**
32		* Constant for specifying the comparison as numeric values.
33		* Values will be converted to float numbers before comparison.
34		*
35		* @see $type
36		*/
37		public const TYPE_NUMBER = 'number';
38
39		private array $validOperatorsMap = [
40		'==' => 1,
41		'===' => 1,
42		'!=' => 1,
43		'!==' => 1,
44		'>' => 1,
45		'>=' => 1,
46		'<' => 1,
47		'<=' => 1,
48		];
49
50	34	public function __construct(
51		/**
52		* @var scalar\|null The constant value to be compared with. When both this property and {@see $targetAttribute}
53		* are set, this property takes precedence.
54		*/
55		private int\|float\|string\|bool\|null $targetValue = null,
56		/**
57		* @var string\|null The name of the attribute to be compared with. When both this property and
58		* {@see $targetValue} are set, the {@see $targetValue} takes precedence.
59		*/
60		private string\|null $targetAttribute = null,
61		private string $incorrectInputMessage = 'The allowed types are integer, float, string, boolean and null.',
62		private string $incorrectDataSetTypeMessage = 'The attribute value returned from a custom data set must have ' .
63		'a scalar type.',
64		/**
65		* @var string\|null User-defined error message.
66		*/
67		private string\|null $message = null,
68		/**
69		* @var string The type of the values being compared.
70		*/
71		private string $type = self::TYPE_STRING,
72		/**
73		* @var string The operator for comparison. The following operators are supported:
74		*
75		* - `==`: check if two values are equal. The comparison is done in non-strict mode.
76		* - `===`: check if two values are equal. The comparison is done in strict mode.
77		* - `!=`: check if two values are NOT equal. The comparison is done in non-strict mode.
78		* - `!==`: check if two values are NOT equal. The comparison is done in strict mode.
79		* - `>`: check if value being validated is greater than the value being compared with.
80		* - `>=`: check if value being validated is greater than or equal to the value being compared with.
81		* - `<`: check if value being validated is less than the value being compared with.
82		* - `<=`: check if value being validated is less than or equal to the value being compared with.
83		*
84		* When you want to compare numbers, make sure to also change {@see $type} to {@see TYPE_NUMBER}.
85		*/
86		private string $operator = '==',
87		/**
88		* @var bool\|callable\|null
89		*/
90		private mixed $skipOnEmpty = null,
91		private bool $skipOnError = false,
92		/**
93		* @var Closure(mixed, ValidationContext):bool\|null
94		*/
95		private ?Closure $when = null,
96		) {
97	34	if (!isset($this->validOperatorsMap[$this->operator])) {
98	1	$validOperatorsString = implode(
99		', ',
100	1	array_map(
101		static fn (string $operator): string => '"' . $operator . '"',
102	1	array_keys($this->validOperatorsMap),
103		),
104		);
105	1	$message = "Operator \"$operator\" is not supported. The valid operators are: $validOperatorsString.";
106
107	1	throw new InvalidArgumentException($message);
108		}
109		}
110
111		/**
112		* @return scalar\|null
113		*/
114	75	public function getTargetValue(): int\|float\|string\|bool\|null
115		{
116	75	return $this->targetValue;
117		}
118
119	75	public function getTargetAttribute(): string\|null
120		{
121	75	return $this->targetAttribute;
122		}
123
124	74	public function getType(): string
125		{
126	74	return $this->type;
127		}
128
129	74	public function getOperator(): string
130		{
131	74	return $this->operator;
132		}
133
134	1	public function getIncorrectInputMessage(): string
135		{
136	1	return $this->incorrectInputMessage;
137		}
138
139	1	public function getIncorrectDataSetTypeMessage(): string
140		{
141	1	return $this->incorrectDataSetTypeMessage;
142		}
143
144	80	public function getMessage(): string
145		{
146	80	return $this->message ?? match ($this->operator) {
147	22	'==', '===' => 'Value must be equal to "{targetValueOrAttribute}".',
148	15	'!=', '!==' => 'Value must not be equal to "{targetValueOrAttribute}".',
149	7	'>' => 'Value must be greater than "{targetValueOrAttribute}".',
150	7	'>=' => 'Value must be greater than or equal to "{targetValueOrAttribute}".',
151	7	'<' => 'Value must be less than "{targetValueOrAttribute}".',
152	80	'<=' => 'Value must be less than or equal to "{targetValueOrAttribute}".',
153		};
154		}
155
156	40	public function getOptions(): array
157		{
158	40	$messageParameters = [
159	40	'targetValue' => $this->targetValue,
160	40	'targetAttribute' => $this->targetAttribute,
161	40	'targetValueOrAttribute' => $this->targetValue ?? $this->targetAttribute,
162		];
163
164		return [
165	40	'targetValue' => $this->targetValue,
166	40	'targetAttribute' => $this->targetAttribute,
167		'incorrectInputMessage' => [
168	40	'message' => $this->incorrectInputMessage,
169		'parameters' => $messageParameters,
170		],
171		'incorrectDataSetTypeMessage' => [
172	40	'message' => $this->incorrectDataSetTypeMessage,
173		'parameters' => $messageParameters,
174		],
175		'message' => [
176	40	'message' => $this->getMessage(),
177		'parameters' => $messageParameters,
178		],
179	40	'type' => $this->type,
180	40	'operator' => $this->operator,
181	40	'skipOnEmpty' => $this->getSkipOnEmptyOption(),
182	40	'skipOnError' => $this->skipOnError,
183		];
184		}
185
186	76	public function getHandlerClassName(): string
187		{
188	76	return CompareHandler::class;
189		}
190		}
191

yiisoft / validator

Pull Request — master (#369)

Compare::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method Many Parameters

Long Method

Many Parameters

Duplication Side-by-Side

Filter issues like