Compare::getOperator() - 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-11 10:42 UTC

Compare::getOperator() A

↳ Parent: Compare

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	1
c	1
b	0
f	0
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
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 $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])) {
            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 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	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 $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	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	75	public function getTargetValue(): int\|float\|string\|bool\|null
106		{
107	75	return $this->targetValue;
108		}
109
110	75	public function getTargetAttribute(): string\|null
111		{
112	75	return $this->targetAttribute;
113		}
114
115	74	public function getType(): string
116		{
117	74	return $this->type;
118		}
119
120	74	public function getOperator(): string
121		{
122	74	return $this->operator;
123		}
124
125	1	public function getIncorrectInputMessage(): string
126		{
127	1	return $this->incorrectInputMessage;
128		}
129
130	1	public function getIncorrectDataSetTypeMessage(): string
131		{
132	1	return $this->incorrectDataSetTypeMessage;
133		}
134
135	80	public function getMessage(): string
136		{
137	80	return $this->message ?? match ($this->operator) {
138	22	'==', '===' => 'Value must be equal to "{targetValueOrAttribute}".',
139	15	'!=', '!==' => 'Value must not be equal to "{targetValueOrAttribute}".',
140	7	'>' => 'Value must be greater than "{targetValueOrAttribute}".',
141	7	'>=' => 'Value must be greater than or equal to "{targetValueOrAttribute}".',
142	7	'<' => 'Value must be less than "{targetValueOrAttribute}".',
143	80	'<=' => 'Value must be less than or equal to "{targetValueOrAttribute}".',
144		};
145		}
146
147	40	public function getOptions(): array
148		{
149	40	$messageParameters = [
150	40	'targetValue' => $this->targetValue,
151	40	'targetAttribute' => $this->targetAttribute,
152	40	'targetValueOrAttribute' => $this->targetValue ?? $this->targetAttribute,
153		];
154
155		return [
156	40	'targetValue' => $this->targetValue,
157	40	'targetAttribute' => $this->targetAttribute,
158		'incorrectInputMessage' => [
159	40	'message' => $this->incorrectInputMessage,
160		'parameters' => $messageParameters,
161		],
162		'incorrectDataSetTypeMessage' => [
163	40	'message' => $this->incorrectDataSetTypeMessage,
164		'parameters' => $messageParameters,
165		],
166		'message' => [
167	40	'message' => $this->getMessage(),
168		'parameters' => $messageParameters,
169		],
170	40	'type' => $this->type,
171	40	'operator' => $this->operator,
172	40	'skipOnEmpty' => $this->getSkipOnEmptyOption(),
173	40	'skipOnError' => $this->skipOnError,
174		];
175		}
176
177	76	public function getHandlerClassName(): string
178		{
179	76	return CompareHandler::class;
180		}
181		}
182

yiisoft / validator

Pull Request — master (#364)

Compare::getOperator() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like