Number::isAsInteger() - Code Metrics - Inspection of "Apply limit interface and traits to `Number` rule" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#422)

by Alexander

created 2022-12-08 10:55 UTC

Number::isAsInteger() A

↳ Parent: Number

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	1
CRAP Score	1

Importance

Changes

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

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule;

use Attribute;
use Closure;
use Yiisoft\Validator\LimitInterface;
use Yiisoft\Validator\Rule\Trait\LimitTrait;
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;

/**
 * Validates 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.
 *
 * @psalm-import-type WhenType from WhenInterface
 */
#[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
final class Number implements
    RuleWithOptionsInterface,
    SkipOnErrorInterface,
    WhenInterface,
    SkipOnEmptyInterface,
    LimitInterface
{
    use LimitTrait;
    use SkipOnEmptyTrait;
    use SkipOnErrorTrait;
    use WhenTrait;

    public function __construct(
        /**
         * @var bool whether the value can only be an integer. Defaults to `false`.
         */
        private bool $asInteger = false,
        /**
         * @var float|int|null lower limit of the number. Defaults to `null`, meaning no lower limit. Can't be combined
         * with {@see $exactly}.
         *
         * @see $lessThanMin for the message used when the number is too small.
         */
        int|float|null $min = null,
        /**
         * @var float|int|null upper limit of the number. Defaults to `null`, meaning no upper limit. Can't be combined
         * with {@see $exactly}.
         *
         * @see $greaterThanMax for the message used when the number is too big.
         */
        int|float|null $max = null,
        /**
         * @var float|int|null exact number. `null` means no strict comparison. Mutually exclusive with {@see $min}
         * and {@see $max}.
         *
         * @see $notExactlyMessage for the message used when the number does not equal to the set one.
         */
        int|float|null $exactly = null,
        private string $incorrectInputMessage = 'The allowed types are integer, float and string.',
        /**
         * @var string error message used when the value is smaller than {@link $min}.
         */
        private string $lessThanMinMessage = 'Value must be no less than {min}.',
        /**
         * @var string error message used when the value is bigger than {@link $max}.
         */
        private string $greaterThanMaxMessage = 'Value must be no greater than {max}.',
        /**
         * @var string error message used when the value does not equal {@see $exactly}.
         */
        private string $notExactlyMessage = 'Value must be equal to {exactly}.',
        /**
         * @var string the regular expression for matching integers.
         */
        private string $integerPattern = '/^\s*[+-]?\d+\s*$/',
        /**
         * @var string the regular expression for matching numbers. It defaults to a pattern
         * that matches floating numbers with optional exponential part (e.g. -1.23e-10).
         */
        private string $numberPattern = '/^\s*[-+]?\d*\.?\d+([eE][-+]?\d+)?\s*$/',


        /**
         * @var bool|callable|null
         */
        private $skipOnEmpty = null,
        private bool $skipOnError = false,
        /**
         * @var WhenType
         */
        private Closure|null $when = null,
    ) {
        $this->initLimitProperties(
            $min,
            $max,
            $exactly,
            $lessThanMinMessage,
            $greaterThanMaxMessage,
            $notExactlyMessage,
            requireLimits: false,
            allowNegativeLimits: true,
        );
    }

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

    public function isAsInteger(): bool
    {
        return $this->asInteger;
    }

    public function getIncorrectInputMessage(): string
    {
        return $this->incorrectInputMessage;
    }

    public function getIntegerPattern(): string
    {
        return $this->integerPattern;
    }

    public function getNumberPattern(): string
    {
        return $this->numberPattern;
    }

    public function getNotNumberMessage(): string
    {
        return $this->asInteger ? 'Value must be an integer.' : 'Value must be a number.';
    }

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

    public function getHandlerClassName(): 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\LimitInterface;
10		use Yiisoft\Validator\Rule\Trait\LimitTrait;
11		use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
12		use Yiisoft\Validator\Rule\Trait\SkipOnErrorTrait;
13		use Yiisoft\Validator\Rule\Trait\WhenTrait;
14		use Yiisoft\Validator\RuleWithOptionsInterface;
15		use Yiisoft\Validator\SkipOnEmptyInterface;
16		use Yiisoft\Validator\SkipOnErrorInterface;
17		use Yiisoft\Validator\WhenInterface;
18
19		/**
20		* Validates that the value is a number.
21		*
22		* The format of the number must match the regular expression specified in {@see Number::$integerPattern}
23		* or {@see Number::$numberPattern}. Optionally, you may configure the {@see Number::min()} and {@see Number::max()}
24		* to ensure the number is within certain range.
25		*
26		* @psalm-import-type WhenType from WhenInterface
27		*/
28		#[Attribute(Attribute::TARGET_PROPERTY \| Attribute::IS_REPEATABLE)]
29		final class Number implements
30		RuleWithOptionsInterface,
31		SkipOnErrorInterface,
32	36	WhenInterface,
33		SkipOnEmptyInterface,
34		LimitInterface
35		{
36		use LimitTrait;
37		use SkipOnEmptyTrait;
38		use SkipOnErrorTrait;
39		use WhenTrait;
40
41		public function __construct(
42		/**
43		* @var bool whether the value can only be an integer. Defaults to `false`.
44		*/
45		private bool $asInteger = false,
46		/**
47		* @var float\|int\|null lower limit of the number. Defaults to `null`, meaning no lower limit. Can't be combined
48		* with {@see $exactly}.
49		*
50		* @see $lessThanMin for the message used when the number is too small.
51		*/
52		int\|float\|null $min = null,
53		/**
54		* @var float\|int\|null upper limit of the number. Defaults to `null`, meaning no upper limit. Can't be combined
55		* with {@see $exactly}.
56		*
57		* @see $greaterThanMax for the message used when the number is too big.
58		*/
59		int\|float\|null $max = null,
60		/**
61		* @var float\|int\|null exact number. `null` means no strict comparison. Mutually exclusive with {@see $min}
62		* and {@see $max}.
63		*
64		* @see $notExactlyMessage for the message used when the number does not equal to the set one.
65		*/
66		int\|float\|null $exactly = null,
67		private string $incorrectInputMessage = 'The allowed types are integer, float and string.',
68		/**
69		* @var string error message used when the value is smaller than {@link $min}.
70		*/
71		private string $lessThanMinMessage = 'Value must be no less than {min}.',
72		/**
73		* @var string error message used when the value is bigger than {@link $max}.
74		*/
75		private string $greaterThanMaxMessage = 'Value must be no greater than {max}.',
76		/**
77		* @var string error message used when the value does not equal {@see $exactly}.
78		*/
79		private string $notExactlyMessage = 'Value must be equal to {exactly}.',
80	10	/**
81		* @var string the regular expression for matching integers.
82	10	*/
83		private string $integerPattern = '/^\s[+-]?\d+\s$/',
84		/**
85	106	* @var string the regular expression for matching numbers. It defaults to a pattern
86		* that matches floating numbers with optional exponential part (e.g. -1.23e-10).
87	106	*/
88		private string $numberPattern = '/^\s[-+]?\d\.?\d+([eE][-+]?\d+)?\s*$/',
89
		0 ignored issues – show Coding Style introduced 2022-12-01 11:29 UTC by Report Bug Copy Issue Report Blank lines are not allowed in a multi-line function declaration Loading history...
90	83	/**
91		* @var bool\|callable\|null
92	83	*/
93		private $skipOnEmpty = null,
94		private bool $skipOnError = false,
95	57	/**
96		* @var WhenType
97	57	*/
98		private Closure\|null $when = null,
99		) {
100	14	$this->initLimitProperties(
101		$min,
102	14	$max,
103		$exactly,
104		$lessThanMinMessage,
105	39	$greaterThanMaxMessage,
106		$notExactlyMessage,
107	39	requireLimits: false,
108		allowNegativeLimits: true,
109		);
110	20	}
111
112	20	public function getName(): string
113		{
114		return 'number';
115	42	}
116
117	42	public function isAsInteger(): bool
118		{
119		return $this->asInteger;
120	64	}
121
122	64	public function getIncorrectInputMessage(): string
123		{
124		return $this->incorrectInputMessage;
125	37	}
126
127	37	public function getIntegerPattern(): string
128		{
129		return $this->integerPattern;
130	14	}
131
132		public function getNumberPattern(): string
133	14	{
134	14	return $this->numberPattern;
135	14	}
136
137	14	public function getNotNumberMessage(): string
138		{
139		return $this->asInteger ? 'Value must be an integer.' : 'Value must be a number.';
140		}
141	14
142		public function getOptions(): array
143		{
144		return array_merge($this->getLimitOptions(), [
145	14	'asInteger' => $this->asInteger,
146	14	'incorrectInputMessage' => [
147		'template' => $this->incorrectInputMessage,
148		'parameters' => [],
149	14	],
150	14	'notNumberMessage' => [
151		'template' => $this->getNotNumberMessage(),
152	14	'parameters' => [],
153	14	],
154	14	'skipOnEmpty' => $this->getSkipOnEmptyOption(),
155	14	'skipOnError' => $this->skipOnError,
156		'integerPattern' => $this->integerPattern,
157		'numberPattern' => $this->numberPattern,
158		]);
159	120	}
160
161	120	public function getHandlerClassName(): string
162		{
163		return NumberHandler::class;
164		}
165		}
166

yiisoft / validator

Pull Request — master (#422)

Number::isAsInteger() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like