AbstractNumber::getNotNumberMessage() - Code Metrics - Inspection of "Use static call in getName() in abstract rule clas..." - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e05223...e18482 )

unknown

created 2023-12-04 11:13 UTC

AbstractNumber::getNotNumberMessage() A

↳ Parent: AbstractNumber

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	1
b	0
f	0

<?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\DumpedRuleInterface;
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 AbstractNumber::$pattern}. Optionally,
 * you may configure the {@see AbstractNumber::$min} and {@see AbstractNumber::$max} to ensure the number is within a
 * certain range.
 *
 * @see NumberHandler
 *
 * @psalm-import-type WhenType from WhenInterface
 */
abstract class AbstractNumber implements
    DumpedRuleInterface,
    SkipOnErrorInterface,
    WhenInterface,
    SkipOnEmptyInterface
{
    use SkipOnEmptyTrait;
    use SkipOnErrorTrait;
    use WhenTrait;

    /**
     * A default for {@see $incorrectInputMessage}.
     */
    protected const DEFAULT_INCORRECT_INPUT_MESSAGE = 'The allowed types are integer, float and string.';
    /**
     * A default for {@see $lessThanMinMessage}.
     */
    protected const DEFAULT_LESS_THAN_MIN_MESSAGE = 'Value must be no less than {min}.';
    /**
     * A default for {@see $greaterThanMaxMessage}.
     */
    protected const DEFAULT_GREATER_THAN_MAX_MESSAGE = 'Value must be no greater than {max}.';

    /**
     * @var string The regular expression for matching numbers.
     * @psalm-var non-empty-string
     */
    private string $pattern;

    /**
     * @param float|int|null $min Lower limit of the number. Defaults to `null`, meaning no lower limit. See
     * {@see $lessThanMinMessage} 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 $greaterThanMaxMessage} 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 $notNumberMessage Error message used when the value does not match {@see $pattern}.
     *
     * You may use the following placeholders in the message:
     *
     * - `{attribute}`: the translated label of the attribute being validated.
     * - `{value}`: actual value.
     * @param string $lessThanMinMessage 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 $greaterThanMaxMessage 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 $pattern The regular expression for matching numbers.
     * @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 float|int|null $min,
        private float|int|null $max,
        private string $incorrectInputMessage,
        private string $notNumberMessage,
        private string $lessThanMinMessage,
        private string $greaterThanMaxMessage,
        string $pattern,
        private mixed $skipOnEmpty,
        private bool $skipOnError,
        private Closure|null $when,
    ) {
        if ($pattern === '') {
            throw new InvalidArgumentException('Pattern can\'t be empty.');
        }

        $this->pattern = $pattern;
    }

    public function getName(): string
    {
        return static::class;
    }

    /**
     * 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 does not match {@see $pattern}
     *
     * @return string Error message.
     *
     * @see $notNumberMessage
     */
    public function getNotNumberMessage(): string
    {
        return $this->notNumberMessage;
    }

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

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

    /**
     * The regular expression for matching numbers.
     *
     * @return string The regular expression.
     * @psalm-return non-empty-string
     *
     * @see $pattern
     */
    public function getPattern(): string
    {
        return $this->pattern;
    }

    public function getOptions(): array
    {
        return [
            'min' => $this->min,
            'max' => $this->max,
            'incorrectInputMessage' => [
                'template' => $this->incorrectInputMessage,
                'parameters' => [],
            ],
            'notNumberMessage' => [
                'template' => $this->notNumberMessage,
                'parameters' => [],
            ],
            'lessThanMinMessage' => [
                'template' => $this->lessThanMinMessage,
                'parameters' => ['min' => $this->min],
            ],
            'greaterThanMaxMessage' => [
                'template' => $this->greaterThanMaxMessage,
                'parameters' => ['max' => $this->max],
            ],
            'skipOnEmpty' => $this->getSkipOnEmptyOption(),
            'skipOnError' => $this->skipOnError,
            'pattern' => $this->pattern,
        ];
    }

    public function getHandler(): string
    {
        return NumberHandler::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\DumpedRuleInterface;
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 AbstractNumber::$pattern}. Optionally,
21			* you may configure the {@see AbstractNumber::$min} and {@see AbstractNumber::$max} to ensure the number is within a
22			* certain range.
23			*
24			* @see NumberHandler
25			*
26			* @psalm-import-type WhenType from WhenInterface
27			*/
28			abstract class AbstractNumber implements
29			DumpedRuleInterface,
30			SkipOnErrorInterface,
31			WhenInterface,
32			SkipOnEmptyInterface
33			{
34			use SkipOnEmptyTrait;
35			use SkipOnErrorTrait;
36			use WhenTrait;
37
38			/**
39			* A default for {@see $incorrectInputMessage}.
40			*/
41			protected const DEFAULT_INCORRECT_INPUT_MESSAGE = 'The allowed types are integer, float and string.';
42			/**
43			* A default for {@see $lessThanMinMessage}.
44			*/
45			protected const DEFAULT_LESS_THAN_MIN_MESSAGE = 'Value must be no less than {min}.';
46			/**
47			* A default for {@see $greaterThanMaxMessage}.
48			*/
49			protected const DEFAULT_GREATER_THAN_MAX_MESSAGE = 'Value must be no greater than {max}.';
50
51			/**
52			* @var string The regular expression for matching numbers.
53			* @psalm-var non-empty-string
54			*/
55			private string $pattern;
56
57			/**
58			* @param float\|int\|null $min Lower limit of the number. Defaults to `null`, meaning no lower limit. See
59			* {@see $lessThanMinMessage} for the customized message used when the number is too small.
60			* @param float\|int\|null $max Upper limit of the number. Defaults to `null`, meaning no upper limit. See
61			* {@see $greaterThanMaxMessage} for the customized message used when the number is too big.
62			* @param string $incorrectInputMessage Error message used when the value is not numeric.
63			*
64			* You may use the following placeholders in the message:
65			*
66			* - `{attribute}`: the translated label of the attribute being validated.
67			* - `{type}`: the type of the value being validated.
68			* @param string $notNumberMessage Error message used when the value does not match {@see $pattern}.
69			*
70			* You may use the following placeholders in the message:
71			*
72			* - `{attribute}`: the translated label of the attribute being validated.
73			* - `{value}`: actual value.
74			* @param string $lessThanMinMessage Error message used when the value is smaller than {@link $min}.
75			*
76			* You may use the following placeholders in the message:
77			*
78			* - `{attribute}`: the translated label of the attribute being validated.
79			* - `{min}`: minimum value.
80			* - `{value}`: actual value.
81			* @param string $greaterThanMaxMessage Error message used when the value is bigger than {@link $max}.
82			*
83			* You may use the following placeholders in the message:
84			*
85			* - `{attribute}`: the translated label of the attribute being validated.
86			* - `{max}`: maximum value.
87			* - `{value}`: actual value.
88			* @param string $pattern The regular expression for matching numbers.
89			* @param bool\|callable\|null $skipOnEmpty Whether to skip this rule if the value validated is empty. See
90			* {@see SkipOnEmptyInterface}.
91			* @param bool $skipOnError Whether to skip this rule if any of the previous rules gave an error. See
92			* {@see SkipOnErrorInterface}.
93			* @param Closure\|null $when A callable to define a condition for applying the rule. See {@see WhenInterface}.
94			*
95			* @psalm-param WhenType $when
96			*/
97			public function __construct(
98			private float\|int\|null $min,
99			private float\|int\|null $max,
100			private string $incorrectInputMessage,
101			private string $notNumberMessage,
102			private string $lessThanMinMessage,
103			private string $greaterThanMaxMessage,
104			string $pattern,
105			private mixed $skipOnEmpty,
106			private bool $skipOnError,
107			private Closure\|null $when,
108			) {
109			if ($pattern === '') {
110			throw new InvalidArgumentException('Pattern can\'t be empty.');
111			}
112
113			$this->pattern = $pattern;
114			}
115
116			public function getName(): string
117			{
118			return static::class;
119			}
120
121			/**
122			* Get lower limit of the number. `null` means no lower limit.
123			*
124			* @return float\|int\|null Lower limit of the number.
125			*
126			* @see $min
127			*/
128			public function getMin(): float\|int\|null
129			{
130			return $this->min;
131			}
132
133			/**
134			* Get upper limit of the number. `null` means no upper limit.
135			*
136			* @return float\|int\|null Upper limit of the number.
137			*
138			* @see $max
139			*/
140			public function getMax(): float\|int\|null
141			{
142			return $this->max;
143			}
144
145			/**
146			* Get error message used when the value is not numeric.
147			*
148			* @return string Error message.
149			*
150			* @see $incorrectInputMessage
151			*/
152			public function getIncorrectInputMessage(): string
153			{
154			return $this->incorrectInputMessage;
155			}
156
157			/**
158			* Get error message used when the value does not match {@see $pattern}
159			*
160			* @return string Error message.
161			*
162			* @see $notNumberMessage
163			*/
164			public function getNotNumberMessage(): string
165			{
166			return $this->notNumberMessage;
167			}
168
169			/**
170			* Get error message used when the value is smaller than {@link $min}.
171			*
172			* @return string Error message.
173			*
174			* @see $lessThanMinMessage
175			*/
176			public function getLessThanMinMessage(): string
177			{
178			return $this->lessThanMinMessage;
179			}
180
181			/**
182			* Get error message used when the value is bigger than {@link $max}.
183			*
184			* @return string Error message.
185			*
186			* @see $greaterThanMaxMessage
187			*/
188			public function getGreaterThanMaxMessage(): string
189			{
190			return $this->greaterThanMaxMessage;
191			}
192
193			/**
194			* The regular expression for matching numbers.
195			*
196			* @return string The regular expression.
197			* @psalm-return non-empty-string
198			*
199			* @see $pattern
200			*/
201			public function getPattern(): string
202			{
203			return $this->pattern;
204			}
205
206			public function getOptions(): array
207			{
208			return [
209			'min' => $this->min,
210			'max' => $this->max,
211			'incorrectInputMessage' => [
212			'template' => $this->incorrectInputMessage,
213			'parameters' => [],
214			],
215			'notNumberMessage' => [
216			'template' => $this->notNumberMessage,
217			'parameters' => [],
218			],
219			'lessThanMinMessage' => [
220			'template' => $this->lessThanMinMessage,
221			'parameters' => ['min' => $this->min],
222			],
223			'greaterThanMaxMessage' => [
224			'template' => $this->greaterThanMaxMessage,
225			'parameters' => ['max' => $this->max],
226			],
227			'skipOnEmpty' => $this->getSkipOnEmptyOption(),
228			'skipOnError' => $this->skipOnError,
229			'pattern' => $this->pattern,
230			];
231			}
232
233			public function getHandler(): string
234			{
235			return NumberHandler::class;
236			}
237			}
238

yiisoft / validator

Push — master ( e05223...e18482 )

AbstractNumber::getNotNumberMessage() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like