Number::__construct() - Code Metrics - Inspection of "More phpdoc" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#490)

by Alexander

created 2022-12-26 17:04 UTC

Number::__construct() A

↳ Parent: Number

Complexity

Conditions	1
Paths	1

Size

Total Lines	13
Code Lines	0

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

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

How to fix Many Parameters

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule;

use Attribute;
use Closure;
use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
use Yiisoft\Validator\Rule\Trait\SkipOnErrorTrait;
use Yiisoft\Validator\Rule\Trait\WhenTrait;
use Yiisoft\Validator\RuleWithOptionsInterface;
use Yiisoft\Validator\SkipOnEmptyInterface;
use Yiisoft\Validator\SkipOnErrorInterface;
use Yiisoft\Validator\WhenInterface;

/**
 * Defines validation options to check that the value is a number.
 *
 * The format of the number must match the regular expression specified in {@see Number::$integerPattern}
 * or {@see Number::$numberPattern}. Optionally, you may configure the {@see Number::min()} and {@see Number::max()}
 * to ensure the number is within certain range.
 *
 * @see NumberHandler
 *
 * @psalm-import-type WhenType from WhenInterface
 */
#[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
final class Number implements RuleWithOptionsInterface, SkipOnErrorInterface, WhenInterface, SkipOnEmptyInterface
{
    use SkipOnEmptyTrait;
    use SkipOnErrorTrait;
    use WhenTrait;

    /**
     * @param bool $integerOnly Whether the value can only be an integer. Defaults to `false`.
     * @param float|int|null $min Lower limit of the number. Defaults to `null`, meaning no lower limit.
     * See {@see $tooSmallMessage} for the customized message used when the number is too small.
     * @param float|int|null $max Upper limit of the number. Defaults to `null`, meaning no upper limit.
     * See {@see $tooBigMessage} for the customized message used when the number is too big.
     * @param string $incorrectInputMessage Error message used when the value is not numeric.
     *
     * You may use the following placeholders in the message:
     *
     * - `{attribute}`: the translated label of the attribute being validated.
     * - `{type}`: the type of the value being validated.
     * @param string $tooSmallMessage Error message used when the value is smaller than {@link $min}.
     *
     * You may use the following placeholders in the message:
     *
     * - `{attribute}`: the translated label of the attribute being validated.
     * - `{min}`: minimum value.
     * - `{value}`: actual value.
     * @param string $tooBigMessage Error message used when the value is bigger than {@link $max}.
     *
     * You may use the following placeholders in the message:
     *
     * - `{attribute}`: the translated label of the attribute being validated.
     * - `{max}`: maximum value.
     * - `{value}`: actual value.
     * @param string $integerPattern The regular expression for matching integers.
     * @param string $numberPattern The regular expression for matching numbers. It defaults to a pattern
     * that matches floating numbers with optional exponential part (e.g. -1.23e-10).
     * @param bool|callable|null $skipOnEmpty Whether to skip this rule if the value validated is empty.
     * See {@see SkipOnEmptyInterface}.
     * @param bool $skipOnError Whether to skip this rule if any of the previous rules gave an error.
     * See {@see SkipOnErrorInterface}.
     * @param Closure|null $when A callable to define a condition for applying the rule.
     * See {@see WhenInterface}.
     * @psalm-param WhenType $when
     */
    public function __construct(
        private bool $integerOnly = false,
        private float|int|null $min = null,
        private float|int|null $max = null,
        private string $incorrectInputMessage = 'The allowed types are integer, float and string.',
        private string $tooSmallMessage = 'Value must be no less than {min}.',
        private string $tooBigMessage = 'Value must be no greater than {max}.',
        private string $integerPattern = '/^\s*[+-]?\d+\s*$/',
        private string $numberPattern = '/^\s*[-+]?\d*\.?\d+([eE][-+]?\d+)?\s*$/',
        private mixed $skipOnEmpty = null,
        private bool $skipOnError = false,
        private Closure|null $when = null,
    ) {
    }

    public function getName(): string
    {
        return 'number';
    }

    /**
     * Whether the value can only be an integer.
     *
     * @return bool Whether the value can only be an integer. Defaults to `false`.
     *
     * @see $integerOnly
     */
    public function isIntegerOnly(): bool
    {
        return $this->integerOnly;
    }

    /**
     * Get lower limit of the number. `null` means no lower limit.
     *
     * @return float|int|null Lower limit of the number.
     *
     * @see $min
     */
    public function getMin(): float|int|null
    {
        return $this->min;
    }

    /**
     * Get upper limit of the number. `null` means no upper limit.
     *
     * @return float|int|null Upper limit of the number.
     *
     * @see $max
     */
    public function getMax(): float|int|null
    {
        return $this->max;
    }

    /**
     * Get error message used when the value is not numeric.
     *
     * @return string Error message.
     *
     * @see $incorrectInputMessage
     */
    public function getIncorrectInputMessage(): string
    {
        return $this->incorrectInputMessage;
    }

    /**
     * Get error message used when the value is smaller than {@link $min}.
     *
     * @return string Error message.
     *
     * @see $tooSmallMessage
     */
    public function getTooSmallMessage(): string
    {
        return $this->tooSmallMessage;
    }

    /**
     * Get error message used when the value is bigger than {@link $max}.
     *
     * @return string Error message.
     *
     * @see $tooBigMessage
     */
    public function getTooBigMessage(): string
    {
        return $this->tooBigMessage;
    }

    /**
     * Get the regular expression for matching integers.
     *
     * @return string The regular expression.
     *
     * @see $integerPattern
     */
    public function getIntegerPattern(): string
    {
        return $this->integerPattern;
    }

    /**
     * The regular expression for matching numbers.
     *
     * @return string The regular expression.
     *
     * @see $numberPattern
     */
    public function getNumberPattern(): string
    {
        return $this->numberPattern;
    }

    /**
     * Get error message used when value type does not match.
     *
     * @return string Error message.
     */
    public function getNotNumberMessage(): string
    {
        return $this->integerOnly ? 'Value must be an integer.' : 'Value must be a number.';
    }

    public function getOptions(): array
    {
        return [
            'asInteger' => $this->integerOnly,
            'min' => $this->min,
            'max' => $this->max,
            'incorrectInputMessage' => [
                'template' => $this->incorrectInputMessage,
                'parameters' => [],
            ],
            'notNumberMessage' => [
                'template' => $this->getNotNumberMessage(),
                'parameters' => [],
            ],
            'tooSmallMessage' => [
                'template' => $this->tooSmallMessage,
                'parameters' => ['min' => $this->min],
            ],
            'tooBigMessage' => [
                'template' => $this->tooBigMessage,
                'parameters' => ['max' => $this->max],
            ],
            'skipOnEmpty' => $this->getSkipOnEmptyOption(),
            'skipOnError' => $this->skipOnError,
            'integerPattern' => $this->integerPattern,
            'numberPattern' => $this->numberPattern,
        ];
    }

    public function getHandler(): string
    {
        return NumberHandler::class;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Validator\Rule;
6
7		use Attribute;
8		use Closure;
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\RuleWithOptionsInterface;
13		use Yiisoft\Validator\SkipOnEmptyInterface;
14		use Yiisoft\Validator\SkipOnErrorInterface;
15		use Yiisoft\Validator\WhenInterface;
16
17		/**
18		* Defines validation options to check that the value is a number.
19		*
20		* The format of the number must match the regular expression specified in {@see Number::$integerPattern}
21		* or {@see Number::$numberPattern}. Optionally, you may configure the {@see Number::min()} and {@see Number::max()}
22		* to ensure the number is within certain range.
23		*
24		* @see NumberHandler
25		*
26		* @psalm-import-type WhenType from WhenInterface
27		*/
28		#[Attribute(Attribute::TARGET_PROPERTY \| Attribute::IS_REPEATABLE)]
29		final class Number implements RuleWithOptionsInterface, SkipOnErrorInterface, WhenInterface, SkipOnEmptyInterface
30		{
31		use SkipOnEmptyTrait;
32	36	use SkipOnErrorTrait;
33		use WhenTrait;
34
35		/**
36		* @param bool $integerOnly Whether the value can only be an integer. Defaults to `false`.
37		* @param float\|int\|null $min Lower limit of the number. Defaults to `null`, meaning no lower limit.
38		* See {@see $tooSmallMessage} for the customized message used when the number is too small.
39		* @param float\|int\|null $max Upper limit of the number. Defaults to `null`, meaning no upper limit.
40		* See {@see $tooBigMessage} for the customized message used when the number is too big.
41		* @param string $incorrectInputMessage Error message used when the value is not numeric.
42		*
43		* You may use the following placeholders in the message:
44		*
45		* - `{attribute}`: the translated label of the attribute being validated.
46		* - `{type}`: the type of the value being validated.
47		* @param string $tooSmallMessage Error message used when the value is smaller than {@link $min}.
48		*
49		* You may use the following placeholders in the message:
50		*
51		* - `{attribute}`: the translated label of the attribute being validated.
52		* - `{min}`: minimum value.
53		* - `{value}`: actual value.
54		* @param string $tooBigMessage Error message used when the value is bigger than {@link $max}.
55		*
56		* You may use the following placeholders in the message:
57		*
58		* - `{attribute}`: the translated label of the attribute being validated.
59		* - `{max}`: maximum value.
60		* - `{value}`: actual value.
61		* @param string $integerPattern The regular expression for matching integers.
62		* @param string $numberPattern The regular expression for matching numbers. It defaults to a pattern
63		* that matches floating numbers with optional exponential part (e.g. -1.23e-10).
64		* @param bool\|callable\|null $skipOnEmpty Whether to skip this rule if the value validated is empty.
65		* See {@see SkipOnEmptyInterface}.
66		* @param bool $skipOnError Whether to skip this rule if any of the previous rules gave an error.
67		* See {@see SkipOnErrorInterface}.
68		* @param Closure\|null $when A callable to define a condition for applying the rule.
69		* See {@see WhenInterface}.
70		* @psalm-param WhenType $when
71		*/
72		public function __construct(
73		private bool $integerOnly = false,
74		private float\|int\|null $min = null,
75		private float\|int\|null $max = null,
76		private string $incorrectInputMessage = 'The allowed types are integer, float and string.',
77		private string $tooSmallMessage = 'Value must be no less than {min}.',
78		private string $tooBigMessage = 'Value must be no greater than {max}.',
79		private string $integerPattern = '/^\s[+-]?\d+\s$/',
80	10	private string $numberPattern = '/^\s[-+]?\d\.?\d+([eE][-+]?\d+)?\s*$/',
81		private mixed $skipOnEmpty = null,
82	10	private bool $skipOnError = false,
83		private Closure\|null $when = null,
84		) {
85	106	}
86
87	106	public function getName(): string
88		{
89		return 'number';
90	83	}
91
92	83	/**
93		* Whether the value can only be an integer.
94		*
95	57	* @return bool Whether the value can only be an integer. Defaults to `false`.
96		*
97	57	* @see $integerOnly
98		*/
99		public function isIntegerOnly(): bool
100	14	{
101		return $this->integerOnly;
102	14	}
103
104		/**
105	39	* Get lower limit of the number. `null` means no lower limit.
106		*
107	39	* @return float\|int\|null Lower limit of the number.
108		*
109		* @see $min
110	20	*/
111		public function getMin(): float\|int\|null
112	20	{
113		return $this->min;
114		}
115	42
116		/**
117	42	* Get upper limit of the number. `null` means no upper limit.
118		*
119		* @return float\|int\|null Upper limit of the number.
120	64	*
121		* @see $max
122	64	*/
123		public function getMax(): float\|int\|null
124		{
125	37	return $this->max;
126		}
127	37
128		/**
129		* Get error message used when the value is not numeric.
130	14	*
131		* @return string Error message.
132		*
133	14	* @see $incorrectInputMessage
134	14	*/
135	14	public function getIncorrectInputMessage(): string
136		{
137	14	return $this->incorrectInputMessage;
138		}
139
140		/**
141	14	* Get error message used when the value is smaller than {@link $min}.
142		*
143		* @return string Error message.
144		*
145	14	* @see $tooSmallMessage
146	14	*/
147		public function getTooSmallMessage(): string
148		{
149	14	return $this->tooSmallMessage;
150	14	}
151
152	14	/**
153	14	* Get error message used when the value is bigger than {@link $max}.
154	14	*
155	14	* @return string Error message.
156		*
157		* @see $tooBigMessage
158		*/
159	120	public function getTooBigMessage(): string
160		{
161	120	return $this->tooBigMessage;
162		}
163
164		/**
165		* Get the regular expression for matching integers.
166		*
167		* @return string The regular expression.
168		*
169		* @see $integerPattern
170		*/
171		public function getIntegerPattern(): string
172		{
173		return $this->integerPattern;
174		}
175
176		/**
177		* The regular expression for matching numbers.
178		*
179		* @return string The regular expression.
180		*
181		* @see $numberPattern
182		*/
183		public function getNumberPattern(): string
184		{
185		return $this->numberPattern;
186		}
187
188		/**
189		* Get error message used when value type does not match.
190		*
191		* @return string Error message.
192		*/
193		public function getNotNumberMessage(): string
194		{
195		return $this->integerOnly ? 'Value must be an integer.' : 'Value must be a number.';
196		}
197
198		public function getOptions(): array
199		{
200		return [
201		'asInteger' => $this->integerOnly,
202		'min' => $this->min,
203		'max' => $this->max,
204		'incorrectInputMessage' => [
205		'template' => $this->incorrectInputMessage,
206		'parameters' => [],
207		],
208		'notNumberMessage' => [
209		'template' => $this->getNotNumberMessage(),
210		'parameters' => [],
211		],
212		'tooSmallMessage' => [
213		'template' => $this->tooSmallMessage,
214		'parameters' => ['min' => $this->min],
215		],
216		'tooBigMessage' => [
217		'template' => $this->tooBigMessage,
218		'parameters' => ['max' => $this->max],
219		],
220		'skipOnEmpty' => $this->getSkipOnEmptyOption(),
221		'skipOnError' => $this->skipOnError,
222		'integerPattern' => $this->integerPattern,
223		'numberPattern' => $this->numberPattern,
224		];
225		}
226
227		public function getHandler(): string
228		{
229		return NumberHandler::class;
230		}
231		}
232

yiisoft / validator

Pull Request — master (#490)

Number::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like