StopOnError::dumpRulesAsArray() - Code Metrics - Inspection of "Docs, part 15" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#496)

unknown

created 2022-12-29 08:15 UTC

StopOnError::dumpRulesAsArray() A

↳ Parent: StopOnError

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	1	Features	0

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

<?php

declare(strict_types=1);

namespace Yiisoft\Validator\Rule;

use Attribute;
use Closure;
use JetBrains\PhpStorm\ArrayShape;
use Yiisoft\Validator\AfterInitAttributeEventInterface;
use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
use Yiisoft\Validator\Rule\Trait\SkipOnErrorTrait;
use Yiisoft\Validator\Rule\Trait\WhenTrait;
use Yiisoft\Validator\RuleInterface;
use Yiisoft\Validator\Helper\RulesDumper;
use Yiisoft\Validator\RuleWithOptionsInterface;
use Yiisoft\Validator\SkipOnEmptyInterface;
use Yiisoft\Validator\SkipOnErrorInterface;
use Yiisoft\Validator\WhenInterface;

/**
 * A higher-order rule, applies to a set of rules, runs validation for each one of them in the order they are defined
 * and stops at the rule where validation failed. In particular, it can be useful for preventing the heavy operations to
 * increase performance. It can be set like that for a group of ordered rules:
 *
 * ```php
 * $rule = new StopOnError([
 *      new HasLength(min: 3),
 *      // This operation executes DB query and thus heavier. It's preferable not to call it if the previous rule did
 *      not pass the validation.
 *      new ExistsInDatabase(),
 * ]);
 * ```
 *
 * Not to be confused with skipping, there is a separate functionality for that, see {@see SkipOnErrorInterface}.
 *
 * @see StopOnErrorHandler Corresponding handler performing the actual validation.
 *
 * @psalm-import-type WhenType from WhenInterface
 */
#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
final class StopOnError implements
    RuleWithOptionsInterface,
    SkipOnErrorInterface,
    WhenInterface,
    SkipOnEmptyInterface,
    AfterInitAttributeEventInterface
{
    use SkipOnEmptyTrait;
    use SkipOnErrorTrait;
    use WhenTrait;

    /**
     * @var RulesDumper|null A rules dumper instance used to dump {@see $rules} as array. Lazily created by
     * {@see getRulesDumper()} only when it's needed.
     */
    private ?RulesDumper $rulesDumper = null;

    /**
     * @param iterable $rules A set of rules for running the validation. Note that they are not normalized.
     * @psalm-param iterable<RuleInterface> $rules
     *
     * @param bool|callable|null $skipOnEmpty Whether to skip this `StopOnError` rule with all defined {@see $rules} if
     * the validated value is empty / not passed. See {@see SkipOnEmptyInterface}.
     * @param bool $skipOnError Whether to skip this `StopOnError` rule with all defined {@see $rules} if any of the
     * previous rules gave an error. See {@see SkipOnErrorInterface}.
     * @param Closure|null $when A callable to define a condition for applying this `StopOnError` rule with all defined
     * {@see $rules}. See {@see WhenInterface}.
     * @psalm-param WhenType $when
     */
    public function __construct(
        private iterable $rules,
        private mixed $skipOnEmpty = null,
        private bool $skipOnError = false,
        private Closure|null $when = null,
    ) {
    }

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

    /**
     * Gets a set of rules for running the validation.
     *
     * @return iterable A set of rules.
     *
     * @psalm-return iterable<RuleInterface>
     */
    public function getRules(): iterable
    {
        return $this->rules;
    }

    #[ArrayShape([
        'skipOnEmpty' => 'bool',
        'skipOnError' => 'bool',
        'rules' => 'array|null',
    ])]
    public function getOptions(): array
    {
        return [
            'skipOnEmpty' => $this->getSkipOnEmptyOption(),
            'skipOnError' => $this->skipOnError,
            'rules' => $this->dumpRulesAsArray(),
        ];
    }

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

    public function afterInitAttribute(object $object, int $target): void
    {
        foreach ($this->rules as $rule) {
            if ($rule instanceof AfterInitAttributeEventInterface) {
                $rule->afterInitAttribute($object, $target);
            }
        }
    }

    /**
     * Dumps defined {@see $rules} to array.
     *
     * @return array The array of rules with their options.
     */
    protected function dumpRulesAsArray(): array
    {
        return $this->getRulesDumper()->asArray($this->getRules());
    }

    /**
     * Returns existing rules dumper instance for dumping defined {@see $rules} as array if it's already set. If not set
     * yet, creates the new instance first.
     *
     * @return RulesDumper A rules dumper instance.
     *
     * @see $rulesDumper
     */
    private function getRulesDumper(): RulesDumper
    {
        if ($this->rulesDumper === null) {
            $this->rulesDumper = new RulesDumper();
        }

        return $this->rulesDumper;

    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Validator\Rule;
6
7		use Attribute;
8		use Closure;
9		use JetBrains\PhpStorm\ArrayShape;
10		use Yiisoft\Validator\AfterInitAttributeEventInterface;
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\RuleInterface;
15		use Yiisoft\Validator\Helper\RulesDumper;
16		use Yiisoft\Validator\RuleWithOptionsInterface;
17		use Yiisoft\Validator\SkipOnEmptyInterface;
18		use Yiisoft\Validator\SkipOnErrorInterface;
19		use Yiisoft\Validator\WhenInterface;
20
21		/**
22		* A higher-order rule, applies to a set of rules, runs validation for each one of them in the order they are defined
23		* and stops at the rule where validation failed. In particular, it can be useful for preventing the heavy operations to
24		* increase performance. It can be set like that for a group of ordered rules:
25		*
26		* ```php
27		* $rule = new StopOnError([
28		* new HasLength(min: 3),
29		* // This operation executes DB query and thus heavier. It's preferable not to call it if the previous rule did
30		* not pass the validation.
31	3	* new ExistsInDatabase(),
32		* ]);
33		* ```
34		*
35		* Not to be confused with skipping, there is a separate functionality for that, see {@see SkipOnErrorInterface}.
36		*
37		* @see StopOnErrorHandler Corresponding handler performing the actual validation.
38		*
39		* @psalm-import-type WhenType from WhenInterface
40		*/
41		#[Attribute(Attribute::TARGET_CLASS \| Attribute::TARGET_PROPERTY \| Attribute::IS_REPEATABLE)]
42		final class StopOnError implements
43		RuleWithOptionsInterface,
44		SkipOnErrorInterface,
45		WhenInterface,
46		SkipOnEmptyInterface,
47		AfterInitAttributeEventInterface
48	1	{
49		use SkipOnEmptyTrait;
50	1	use SkipOnErrorTrait;
51		use WhenTrait;
52
53		/**
54		* @var RulesDumper\|null A rules dumper instance used to dump {@see $rules} as array. Lazily created by
55		* {@see getRulesDumper()} only when it's needed.
56	3	*/
57		private ?RulesDumper $rulesDumper = null;
58	3
59		/**
60		* @param iterable $rules A set of rules for running the validation. Note that they are not normalized.
61	1	* @psalm-param iterable<RuleInterface> $rules
62		*
63		* @param bool\|callable\|null $skipOnEmpty Whether to skip this `StopOnError` rule with all defined {@see $rules} if
64		* the validated value is empty / not passed. See {@see SkipOnEmptyInterface}.
65		* @param bool $skipOnError Whether to skip this `StopOnError` rule with all defined {@see $rules} if any of the
66		* previous rules gave an error. See {@see SkipOnErrorInterface}.
67		* @param Closure\|null $when A callable to define a condition for applying this `StopOnError` rule with all defined
68		* {@see $rules}. See {@see WhenInterface}.
69	1	* @psalm-param WhenType $when
70	1	*/
71	1	public function __construct(
72		private iterable $rules,
73		private mixed $skipOnEmpty = null,
74		private bool $skipOnError = false,
75	3	private Closure\|null $when = null,
76		) {
77	3	}
78
79		public function getName(): string
80		{
81		return 'stopOnError';
82		}
83
84		/**
85		* Gets a set of rules for running the validation.
86		*
87		* @return iterable A set of rules.
88		*
89		* @psalm-return iterable<RuleInterface>
90		*/
91		public function getRules(): iterable
92		{
93		return $this->rules;
94		}
95
96		#[ArrayShape([
97		'skipOnEmpty' => 'bool',
98		'skipOnError' => 'bool',
99		'rules' => 'array\|null',
100		])]
101		public function getOptions(): array
102		{
103		return [
104		'skipOnEmpty' => $this->getSkipOnEmptyOption(),
105		'skipOnError' => $this->skipOnError,
106		'rules' => $this->dumpRulesAsArray(),
107		];
108		}
109
110		public function getHandler(): string
111		{
112		return StopOnErrorHandler::class;
113		}
114
115		public function afterInitAttribute(object $object, int $target): void
116		{
117		foreach ($this->rules as $rule) {
118		if ($rule instanceof AfterInitAttributeEventInterface) {
119		$rule->afterInitAttribute($object, $target);
120		}
121		}
122		}
123
124		/**
125		* Dumps defined {@see $rules} to array.
126		*
127		* @return array The array of rules with their options.
128		*/
129		protected function dumpRulesAsArray(): array
130		{
131		return $this->getRulesDumper()->asArray($this->getRules());
132		}
133
134		/**
135		* Returns existing rules dumper instance for dumping defined {@see $rules} as array if it's already set. If not set
136		* yet, creates the new instance first.
137		*
138		* @return RulesDumper A rules dumper instance.
139		*
140		* @see $rulesDumper
141		*/
142		private function getRulesDumper(): RulesDumper
143		{
144		if ($this->rulesDumper === null) {
145		$this->rulesDumper = new RulesDumper();
146		}
147
148		return $this->rulesDumper;
		0 ignored issues – show Bug Best Practice introduced 2022-12-11 18:16 UTC by Report Bug Copy Issue Report The expression `return $this->rulesDumper` could return the type `null` which is incompatible with the type-hinted return `Yiisoft\Validator\Helper\RulesDumper`. Consider adding an additional type-check to rule them out. Loading history...
149		}
150		}
151

yiisoft / validator

Pull Request — master (#496)

StopOnError::dumpRulesAsArray() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like