Url::isEnableIDN() - Code Metrics - Inspection of "Clean up/add docs for Url and UrlHandler" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#474)

unknown

created 2022-12-21 08:10 UTC

Url::isEnableIDN() A

↳ Parent: Url

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 RuntimeException;
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;

use function function_exists;

/**
 * Validates that the value is a valid HTTP or HTTPS URL.
 *
 * Note that this rule only checks if the URL scheme and host parts are correct.
 * It does not check the remaining parts of a URL.
 *
 * @psalm-import-type WhenType from WhenInterface
 *
 * @see UrlHandler
 */
#[Attribute(Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
final class Url implements RuleWithOptionsInterface, SkipOnErrorInterface, WhenInterface, SkipOnEmptyInterface
{
    use SkipOnEmptyTrait;
    use SkipOnErrorTrait;
    use WhenTrait;

    /**
     * @param string $pattern The regular expression used to validate the value.
     * The pattern may contain a `{schemes}` token that will be replaced
     * by a regular expression which represents the {@see $schemes}.
     *
     * Note that if you want to reuse the pattern in HTML5 input, it should have `^` and `$`, should not have any
     * modifiers and should not be case-insensitive.
     * @param string[] $validSchemes List of URI schemes which should be considered valid. By default, http and https
     * are considered to be valid schemes.
     * @param bool $enableIdn Whether the validation process must take
     * {@link https://en.wikipedia.org/wiki/Internationalized_domain_name IDN (internationalized domain names)}
     * into account . Defaults to `false` meaning that validation of URLs containing IDN will always
     * fail. Note that in order to use IDN validation you have to install and enable `intl` PHP
     * extension, otherwise an exception will be thrown.
     * @param string $incorrectInputMessage A message used when the input is incorrect.
     *
     * You may use the following placeholders in the message:
     *
     * - `{attribute}`: the label of the attribute being validated.
     * - `{type}`: the value's type.
     * @param string $message @var string A message used when the value is not valid.
     *
     * You may use the following placeholders in the message:
     *
     * - `{attribute}`: the label of the attribute being validated.
     * - `{value}`: the value of the attribute being validated.
     * @param bool|callable|null $skipOnEmpty Whether to skip this rule if the validated value 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 string $pattern = '/^{schemes}:\/\/(([a-zA-Z0-9][a-zA-Z0-9_-]*)(\.[a-zA-Z0-9][a-zA-Z0-9_-]*)+)(?::\d{1,5})?([?\/#].*$|$)/',
        private array $validSchemes = ['http', 'https'],
        private bool $enableIdn = false,
        private string $incorrectInputMessage = 'The value must have a string type.',
        private string $message = 'This value is not a valid URL.',
        private $skipOnEmpty = null,
        private bool $skipOnError = false,
        private Closure|null $when = null,
    ) {
        if ($enableIdn && !function_exists('idn_to_ascii')) {
            // Tested via separate CI configuration (see ".github/workflows/build.yml").
            // @codeCoverageIgnoreStart
            throw new RuntimeException('In order to use IDN validation intl extension must be installed and enabled.');
            // @codeCoverageIgnoreEnd
        }
    }

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

    /**
     * Get ready to use regular expression pattern applied for URL validation.
     *
     * @return string Regular expression pattern applied for URL validation.
     */
    public function getPattern(): string
    {
        return str_replace('{schemes}', '((?i)' . implode('|', $this->validSchemes) . ')', $this->pattern);
    }

    /**
     * Get valid URI schemas.
     *
     * @return string[] List of URI schemes which should be considered valid. By default, http and https
     * are considered to be valid schemes.
     *
     * @see $validSchemes
     */
    public function getValidSchemes(): array
    {
        return $this->validSchemes;
    }

    /**
     * Whether the validation process must take
     * {@link https://en.wikipedia.org/wiki/Internationalized_domain_name IDN (internationalized domain names)}
     * into account. `false` means that validation of URLs containing IDN will always
     * fail. Note that in order to use IDN validation you have to install and enable `intl` PHP
     * extension, otherwise an exception will be thrown.
     *
     * @return bool Whether to enable IDN validation.
     *
     * @see $enableIdn
     */
    public function isIdnEnabled(): bool
    {
        return $this->enableIdn;
    }

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

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

    public function getOptions(): array
    {
        return [
            'pattern' => $this->getPattern(),
            'validSchemes' => $this->validSchemes,
            'enableIdn' => $this->enableIdn,
            'incorrectInputMessage' => [
                'template' => $this->incorrectInputMessage,
                'parameters' => [],
            ],
            'message' => [
                'template' => $this->message,
                'parameters' => [],
            ],
            'skipOnEmpty' => $this->getSkipOnEmptyOption(),
            'skipOnError' => $this->skipOnError,
        ];
    }

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


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Validator\Rule;
6
7		use Attribute;
8		use Closure;
9		use RuntimeException;
10		use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
11		use Yiisoft\Validator\Rule\Trait\SkipOnErrorTrait;
12		use Yiisoft\Validator\Rule\Trait\WhenTrait;
13		use Yiisoft\Validator\RuleWithOptionsInterface;
14		use Yiisoft\Validator\SkipOnEmptyInterface;
15		use Yiisoft\Validator\SkipOnErrorInterface;
16		use Yiisoft\Validator\WhenInterface;
17
18		use function function_exists;
19
20		/**
21		* Validates that the value is a valid HTTP or HTTPS URL.
22		*
23		* Note that this rule only checks if the URL scheme and host parts are correct.
24		* It does not check the remaining parts of a URL.
25		*
26		* @psalm-import-type WhenType from WhenInterface
27		*
28		* @see UrlHandler
29		*/
30		#[Attribute(Attribute::TARGET_PROPERTY \| Attribute::IS_REPEATABLE)]
31		final class Url implements RuleWithOptionsInterface, SkipOnErrorInterface, WhenInterface, SkipOnEmptyInterface
32		{
33		use SkipOnEmptyTrait;
34	4	use SkipOnErrorTrait;
35		use WhenTrait;
36
37		/**
38		* @param string $pattern The regular expression used to validate the value.
39		* The pattern may contain a `{schemes}` token that will be replaced
40		* by a regular expression which represents the {@see $schemes}.
41		*
42		* Note that if you want to reuse the pattern in HTML5 input, it should have `^` and `$`, should not have any
43		* modifiers and should not be case-insensitive.
44		* @param string[] $validSchemes List of URI schemes which should be considered valid. By default, http and https
45		* are considered to be valid schemes.
46		* @param bool $enableIdn Whether the validation process must take
47		* {@link https://en.wikipedia.org/wiki/Internationalized_domain_name IDN (internationalized domain names)}
48		* into account . Defaults to `false` meaning that validation of URLs containing IDN will always
49		* fail. Note that in order to use IDN validation you have to install and enable `intl` PHP
50		* extension, otherwise an exception will be thrown.
51		* @param string $incorrectInputMessage A message used when the input is incorrect.
52		*
53		* You may use the following placeholders in the message:
54		*
55		* - `{attribute}`: the label of the attribute being validated.
56		* - `{type}`: the value's type.
57		* @param string $message @var string A message used when the value is not valid.
58		*
59		* You may use the following placeholders in the message:
60		*
61		* - `{attribute}`: the label of the attribute being validated.
62		* - `{value}`: the value of the attribute being validated.
63		* @param bool\|callable\|null $skipOnEmpty Whether to skip this rule if the validated value is empty. See {@see SkipOnEmptyInterface}.
64		* @param bool $skipOnError Whether to skip this rule if any of the previous rules gave an error. See {@see SkipOnErrorInterface}.
65		* @param Closure\|null $when A callable to define a condition for applying the rule. See {@see WhenInterface}.
66		* @psalm-param WhenType $when
67		*/
68		public function __construct(
69	4	private string $pattern = '/^{schemes}:\/\/(([a-zA-Z0-9][a-zA-Z0-9_-])(\.[a-zA-Z0-9][a-zA-Z0-9_-])+)(?::\d{1,5})?([?\/#].*$\|$)/',
70		private array $validSchemes = ['http', 'https'],
71		private bool $enableIdn = false,
72		private string $incorrectInputMessage = 'The value must have a string type.',
73		private string $message = 'This value is not a valid URL.',
74		private $skipOnEmpty = null,
75		private bool $skipOnError = false,
76		private Closure\|null $when = null,
77	1	) {
78		if ($enableIdn && !function_exists('idn_to_ascii')) {
79	1	// Tested via separate CI configuration (see ".github/workflows/build.yml").
80		// @codeCoverageIgnoreStart
81		throw new RuntimeException('In order to use IDN validation intl extension must be installed and enabled.');
82	44	// @codeCoverageIgnoreEnd
83		}
84	44	}
85
86		public function getName(): string
87		{
88		return 'url';
89		}
90	2
91		/**
92	2	* Get ready to use regular expression pattern applied for URL validation.
93		*
94		* @return string Regular expression pattern applied for URL validation.
95	40	*/
96		public function getPattern(): string
97	40	{
98		return str_replace('{schemes}', '((?i)' . implode('\|', $this->validSchemes) . ')', $this->pattern);
99		}
100	6
101		/**
102	6	* Get valid URI schemas.
103		*
104		* @return string[] List of URI schemes which should be considered valid. By default, http and https
105	19	* are considered to be valid schemes.
106		*
107	19	* @see $validSchemes
108		*/
109		public function getValidSchemes(): array
110	4	{
111		return $this->validSchemes;
112		}
113	4
114	4	/**
115	4	* Whether the validation process must take
116		* {@link https://en.wikipedia.org/wiki/Internationalized_domain_name IDN (internationalized domain names)}
117	4	* into account. `false` means that validation of URLs containing IDN will always
118		* fail. Note that in order to use IDN validation you have to install and enable `intl` PHP
119		* extension, otherwise an exception will be thrown.
120		*
121	4	* @return bool Whether to enable IDN validation.
122		*
123		* @see $enableIdn
124	4	*/
125	4	public function isIdnEnabled(): bool
126		{
127		return $this->enableIdn;
128		}
129	48
130		/**
131	48	* Get a message used when the input is incorrect.
132		*
133		* @return string Error message.
134		*
135		* @see $incorrectInputMessage
136		*/
137		public function getIncorrectInputMessage(): string
138		{
139		return $this->incorrectInputMessage;
140		}
141
142		/**
143		* Get a message used when the value is not valid.
144		*
145		* @return string Error message.
146		*
147		* @see $message
148		*/
149		public function getMessage(): string
150		{
151		return $this->message;
152		}
153
154		public function getOptions(): array
155		{
156		return [
157		'pattern' => $this->getPattern(),
158		'validSchemes' => $this->validSchemes,
159		'enableIdn' => $this->enableIdn,
160		'incorrectInputMessage' => [
161		'template' => $this->incorrectInputMessage,
162		'parameters' => [],
163		],
164		'message' => [
165		'template' => $this->message,
166		'parameters' => [],
167		],
168		'skipOnEmpty' => $this->getSkipOnEmptyOption(),
169		'skipOnError' => $this->skipOnError,
170		];
171		}
172
173		public function getHandler(): string
174		{
175		return UrlHandler::class;
176		}
177		}
178

yiisoft / validator

Pull Request — master (#474)

Url::isEnableIDN() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like