Compare::__construct() - Code Metrics - Inspection of "Fix #132: Adjust skip on empty (#288)" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( cd2db1...fdabae )

by Alexander

created 2022-08-21 13:32 UTC

Compare::__construct() A

↳ Parent: Compare

Complexity

Conditions	2
Paths	2

Size

Total Lines	52
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	2.0625

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
eloc	3
c	1
b	0
f	0
dl	0
loc	52
ccs	3
cts	4
cp	0.75
rs	10
cc	2
nc	2
nop	9
crap	2.0625

How to fix Long Method Many Parameters

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule;

use Closure;
use InvalidArgumentException;
use RuntimeException;
use Yiisoft\Validator\BeforeValidationInterface;
use Yiisoft\Validator\Rule\Trait\BeforeValidationTrait;
use Yiisoft\Validator\Rule\Trait\RuleNameTrait;
use Yiisoft\Validator\SerializableRuleInterface;
use Yiisoft\Validator\ValidationContext;

abstract class Compare implements SerializableRuleInterface, BeforeValidationInterface
{
    use BeforeValidationTrait;
    use RuleNameTrait;

    /**
     * Constant for specifying the comparison as string values.
     * No conversion will be done before comparison.
     *
     * @see $type
     */
    public const TYPE_STRING = 'string';
    /**
     * Constant for specifying the comparison as numeric values.
     * String values will be converted into numbers before comparison.
     *
     * @see $type
     */
    public const TYPE_NUMBER = 'number';

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

    public function __construct(
        /**
         * @var mixed The constant value to be compared with. When both this property
         * and {@see $targetAttribute} are set, this property takes precedence.
         */
        private $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.
         *
         * @see $targetValue
         */
        private ?string $targetAttribute = null,
        /**
         * @var string|null User-defined error message.
         */
        private ?string $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 is non-strict mode.
         * - `===`: check if two values are equal. The comparison is done is strict mode.
         * - `!=`: check if two values are NOT equal. The comparison is done is non-strict mode.
         * - `!==`: check if two values are NOT equal. The comparison is done is 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 = '==',
        private bool $skipOnEmpty = false,
        /**
         * @var callable
         */
        private $skipOnEmptyCallback = null,
        private bool $skipOnError = false,
        /**
         * @var Closure(mixed, ValidationContext):bool|null
         */
        private ?Closure $when = null,
    ) {
        $this->initSkipOnEmptyProperties($skipOnEmpty, $skipOnEmptyCallback);

        if (!isset($this->validOperators[$operator])) {
            throw new InvalidArgumentException("Operator \"$operator\" is not supported.");
        }
    }

    public function getTargetValue(): mixed
    {
        return $this->targetValue;
    }

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

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

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

    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}".',
            default => throw new RuntimeException("Unknown operator: $this->operator."),
        };
    }

    public function getOptions(): array
    {
        return [
            'targetValue' => $this->targetValue,
            'targetAttribute' => $this->targetAttribute,
            'message' => [
                'message' => $this->getMessage(),
                'parameters' => [
                    'targetValue' => $this->targetValue,
                    'targetAttribute' => $this->targetAttribute,
                    'targetValueOrAttribute' => $this->targetValue ?? $this->targetAttribute,
                ],
            ],
            'type' => $this->type,
            'operator' => $this->operator,
            'skipOnEmpty' => $this->skipOnEmpty,
            '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 RuntimeException;
10		use Yiisoft\Validator\BeforeValidationInterface;
11		use Yiisoft\Validator\Rule\Trait\BeforeValidationTrait;
12		use Yiisoft\Validator\Rule\Trait\RuleNameTrait;
13		use Yiisoft\Validator\SerializableRuleInterface;
14		use Yiisoft\Validator\ValidationContext;
15
16		abstract class Compare implements SerializableRuleInterface, BeforeValidationInterface
17		{
18		use BeforeValidationTrait;
19		use RuleNameTrait;
20
21		/**
22		* Constant for specifying the comparison as string values.
23		* No conversion will be done before comparison.
24		*
25		* @see $type
26		*/
27		public const TYPE_STRING = 'string';
28		/**
29		* Constant for specifying the comparison as numeric values.
30		* String values will be converted into numbers before comparison.
31		*
32		* @see $type
33		*/
34		public const TYPE_NUMBER = 'number';
35
36		private array $validOperators = [
37		'==' => 1,
38		'===' => 1,
39		'!=' => 1,
40		'!==' => 1,
41		'>' => 1,
42		'>=' => 1,
43		'<' => 1,
44		'<=' => 1,
45		];
46
47	28	public function __construct(
48		/**
49		* @var mixed The constant value to be compared with. When both this property
50		* and {@see $targetAttribute} are set, this property takes precedence.
51		*/
52		private $targetValue = null,
53		/**
54		* @var string\|null The name of the attribute to be compared with. When both this property
55		* and {@see $targetValue} are set, the {@see $targetValue} takes precedence.
56		*
57		* @see $targetValue
58		*/
59		private ?string $targetAttribute = null,
60		/**
61		* @var string\|null User-defined error message.
62		*/
63		private ?string $message = null,
64		/**
65		* @var string The type of the values being compared.
66		*/
67		private string $type = self::TYPE_STRING,
68		/**
69		* @var string The operator for comparison. The following operators are supported:
70		*
71		* - `==`: check if two values are equal. The comparison is done is non-strict mode.
72		* - `===`: check if two values are equal. The comparison is done is strict mode.
73		* - `!=`: check if two values are NOT equal. The comparison is done is non-strict mode.
74		* - `!==`: check if two values are NOT equal. The comparison is done is strict mode.
75		* - `>`: check if value being validated is greater than the value being compared with.
76		* - `>=`: check if value being validated is greater than or equal to the value being compared with.
77		* - `<`: check if value being validated is less than the value being compared with.
78		* - `<=`: check if value being validated is less than or equal to the value being compared with.
79		*
80		* When you want to compare numbers, make sure to also change @see $type} to
81		* {@see TYPE_NUMBER}.
82		*/
83		private string $operator = '==',
84		private bool $skipOnEmpty = false,
85		/**
86		* @var callable
87		*/
88		private $skipOnEmptyCallback = null,
89		private bool $skipOnError = false,
90		/**
91		* @var Closure(mixed, ValidationContext):bool\|null
92		*/
93		private ?Closure $when = null,
94		) {
95	28	$this->initSkipOnEmptyProperties($skipOnEmpty, $skipOnEmptyCallback);
96
97	28	if (!isset($this->validOperators[$operator])) {
98		throw new InvalidArgumentException("Operator \"$operator\" is not supported.");
99		}
100		}
101
102	67	public function getTargetValue(): mixed
103		{
104	67	return $this->targetValue;
105		}
106
107	67	public function getTargetAttribute(): ?string
108		{
109	67	return $this->targetAttribute;
110		}
111
112	67	public function getType(): string
113		{
114	67	return $this->type;
115		}
116
117	67	public function getOperator(): string
118		{
119	67	return $this->operator;
120		}
121
122	82	public function getMessage(): string
123		{
124	82	return $this->message ?? match ($this->operator) {
125	19	'==', '===' => 'Value must be equal to "{targetValueOrAttribute}".',
126	16	'!=', '!==' => 'Value must not be equal to "{targetValueOrAttribute}".',
127	8	'>' => 'Value must be greater than "{targetValueOrAttribute}".',
128	8	'>=' => 'Value must be greater than or equal to "{targetValueOrAttribute}".',
129	8	'<' => 'Value must be less than "{targetValueOrAttribute}".',
130	8	'<=' => 'Value must be less than or equal to "{targetValueOrAttribute}".',
131	82	default => throw new RuntimeException("Unknown operator: $this->operator."),
132		};
133		}
134
135	45	public function getOptions(): array
136		{
137		return [
138	45	'targetValue' => $this->targetValue,
139	45	'targetAttribute' => $this->targetAttribute,
140		'message' => [
141	45	'message' => $this->getMessage(),
142		'parameters' => [
143	45	'targetValue' => $this->targetValue,
144	45	'targetAttribute' => $this->targetAttribute,
145	45	'targetValueOrAttribute' => $this->targetValue ?? $this->targetAttribute,
146		],
147		],
148	45	'type' => $this->type,
149	45	'operator' => $this->operator,
150	45	'skipOnEmpty' => $this->skipOnEmpty,
151	45	'skipOnError' => $this->skipOnError,
152		];
153		}
154
155	8	public function getHandlerClassName(): string
156		{
157	8	return CompareHandler::class;
158		}
159		}
160

yiisoft / validator

Push — master ( cd2db1...fdabae )

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