Compare::getOptions() - Code Metrics - Inspection of "Set Psalm level to 1" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#364)

unknown

created 2022-11-10 11:47 UTC

Compare::getOptions() A

↳ Parent: Compare

Complexity

Conditions	1
Paths	1

Size

Total Lines	26
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	14
CRAP Score	1

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
eloc	19
c	2
b	0
f	0
dl	0
loc	26
ccs	14
cts	14
cp	1
rs	9.6333
cc	1
nc	1
nop	0
crap	1

<?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 $incorrectDataSetTypeMessage = 'The attribute value returned from a custom data set must have ' .
        'a scalar type.',
        private string|null $nonScalarMessage = null,
        /**
         * @var string|null User-defined error message.
         */
        private string|null $scalarMessage = 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])) {
            throw new InvalidArgumentException("Operator \"$operator\" is not supported.");
        }
    }

    /**
     * @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 getIncorrectDataSetTypeMessage(): string
    {
        return $this->incorrectDataSetTypeMessage;
    }

    public function getNonScalarMessage(): string
    {
        return $this->nonScalarMessage ?? match ($this->operator) {
            '==', '===' => 'The non-scalar value must be equal to "{targetValueOrAttribute}".',
            '!=', '!==' => 'The non-scalar value must not be equal to "{targetValueOrAttribute}".',
            '>' => 'The non-scalar value must be greater than "{targetValueOrAttribute}".',
            '>=' => 'The non-scalar value must be greater than or equal to "{targetValueOrAttribute}".',
            '<' => 'The non-scalar value must be less than "{targetValueOrAttribute}".',
            '<=' => 'The non-scalar value must be less than or equal to "{targetValueOrAttribute}".',
        };
    }

    public function getScalarMessage(): string
    {
        return $this->scalarMessage ?? match ($this->operator) {
            '==', '===' => 'The scalar value must be equal to "{targetValueOrAttribute}".',
            '!=', '!==' => 'The scalar value must not be equal to "{targetValueOrAttribute}".',
            '>' => 'The scalar value must be greater than "{targetValueOrAttribute}".',
            '>=' => 'The scalar value must be greater than or equal to "{targetValueOrAttribute}".',
            '<' => 'The scalar value must be less than "{targetValueOrAttribute}".',
            '<=' => 'The scalar 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,
            'incorrectDataSetTypeMessage' => [
                'message' => $this->incorrectDataSetTypeMessage,
            ],
            'nonScalarMessage' => [
                'message' => $this->getNonScalarMessage(),
                'parameters' => $messageParameters,
            ],
            'scalarMessage' => [
                'message' => $this->getScalarMessage(),
                '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	33	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 $incorrectDataSetTypeMessage = 'The attribute value returned from a custom data set must have ' .
62		'a scalar type.',
63		private string\|null $nonScalarMessage = null,
64		/**
65		* @var string\|null User-defined error message.
66		*/
67		private string\|null $scalarMessage = 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	33	if (!isset($this->validOperatorsMap[$this->operator])) {
98		throw new InvalidArgumentException("Operator \"$operator\" is not supported.");
99		}
100		}
101
102		/**
103		* @return scalar\|null
104		*/
105	72	public function getTargetValue(): int\|float\|string\|bool\|null
106		{
107	72	return $this->targetValue;
108		}
109
110	72	public function getTargetAttribute(): string\|null
111		{
112	72	return $this->targetAttribute;
113		}
114
115	71	public function getType(): string
116		{
117	71	return $this->type;
118		}
119
120	71	public function getOperator(): string
121		{
122	71	return $this->operator;
123		}
124
125	1	public function getIncorrectDataSetTypeMessage(): string
126		{
127	1	return $this->incorrectDataSetTypeMessage;
128		}
129
130	40	public function getNonScalarMessage(): string
131		{
132	40	return $this->nonScalarMessage ?? match ($this->operator) {
133	15	'==', '===' => 'The non-scalar value must be equal to "{targetValueOrAttribute}".',
134	8	'!=', '!==' => 'The non-scalar value must not be equal to "{targetValueOrAttribute}".',
135	4	'>' => 'The non-scalar value must be greater than "{targetValueOrAttribute}".',
136	5	'>=' => 'The non-scalar value must be greater than or equal to "{targetValueOrAttribute}".',
137	4	'<' => 'The non-scalar value must be less than "{targetValueOrAttribute}".',
138	40	'<=' => 'The non-scalar value must be less than or equal to "{targetValueOrAttribute}".',
139		};
140		}
141
142	79	public function getScalarMessage(): string
143		{
144	79	return $this->scalarMessage ?? match ($this->operator) {
145	21	'==', '===' => 'The scalar value must be equal to "{targetValueOrAttribute}".',
146	15	'!=', '!==' => 'The scalar value must not be equal to "{targetValueOrAttribute}".',
147	7	'>' => 'The scalar value must be greater than "{targetValueOrAttribute}".',
148	7	'>=' => 'The scalar value must be greater than or equal to "{targetValueOrAttribute}".',
149	7	'<' => 'The scalar value must be less than "{targetValueOrAttribute}".',
150	79	'<=' => 'The scalar value must be less than or equal to "{targetValueOrAttribute}".',
151		};
152		}
153
154	40	public function getOptions(): array
155		{
156	40	$messageParameters = [
157	40	'targetValue' => $this->targetValue,
158	40	'targetAttribute' => $this->targetAttribute,
159	40	'targetValueOrAttribute' => $this->targetValue ?? $this->targetAttribute,
160		];
161
162		return [
163	40	'targetValue' => $this->targetValue,
164	40	'targetAttribute' => $this->targetAttribute,
165		'incorrectDataSetTypeMessage' => [
166	40	'message' => $this->incorrectDataSetTypeMessage,
167		],
168		'nonScalarMessage' => [
169	40	'message' => $this->getNonScalarMessage(),
170		'parameters' => $messageParameters,
171		],
172		'scalarMessage' => [
173	40	'message' => $this->getScalarMessage(),
174		'parameters' => $messageParameters,
175		],
176	40	'type' => $this->type,
177	40	'operator' => $this->operator,
178	40	'skipOnEmpty' => $this->getSkipOnEmptyOption(),
179	40	'skipOnError' => $this->skipOnError,
180		];
181		}
182
183	72	public function getHandlerClassName(): string
184		{
185	72	return CompareHandler::class;
186		}
187		}
188

yiisoft / validator

Pull Request — master (#364)

Compare::getOptions() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like