Composite::getRules() - Code Metrics - Inspection of "Adapt `Composite` rule to inheritance usage (#441)" - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( c5e9e9...342519 )

by Sergei

created 2022-12-09 08:33 UTC

Composite::getRules() A

↳ Parent: Composite

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	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	3
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\Helper\RulesNormalizer;
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\RulesDumper;
use Yiisoft\Validator\RuleWithOptionsInterface;
use Yiisoft\Validator\SkipOnEmptyInterface;
use Yiisoft\Validator\SkipOnErrorInterface;
use Yiisoft\Validator\WhenInterface;

/**
 * Allows to combine and validate multiple rules.
 *
 * @psalm-import-type WhenType from WhenInterface
 */
#[Attribute(Attribute::TARGET_CLASS | Attribute::TARGET_PROPERTY | Attribute::IS_REPEATABLE)]
class Composite implements
    RuleWithOptionsInterface,
    SkipOnErrorInterface,
    WhenInterface,
    SkipOnEmptyInterface,
    AfterInitAttributeEventInterface
{
    use SkipOnEmptyTrait;
    use SkipOnErrorTrait;
    use WhenTrait;

    /**
     * @var iterable<int, RuleInterface>
     */
    protected iterable $rules = [];

    /**
     * @var bool|callable|null
     */
    protected $skipOnEmpty = null;

    protected bool $skipOnError = false;

    /**
     * @psalm-var WhenType
     */
    protected Closure|null $when = null;

    private ?RulesDumper $rulesDumper = null;

    /**
     * @param iterable<Closure|RuleInterface> $rules
     *
     * @psalm-param WhenType $when
     */
    public function __construct(
        iterable $rules = [],
        bool|callable|null $skipOnEmpty = null,
        bool $skipOnError = false,
        Closure|null $when = null,
    ) {
        $this->rules = RulesNormalizer::normalizeList($rules);
        $this->skipOnEmpty = $skipOnEmpty;
        $this->skipOnError = $skipOnError;
        $this->when = $when;
    }

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

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

    /**
     * @return iterable<int, RuleInterface>
     */
    public function getRules(): iterable
    {
        return $this->rules;
    }

    final public function getHandlerClassName(): string
    {
        return CompositeHandler::class;
    }

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

    final protected function dumpRulesAsArray(): array
    {
        return $this->getRulesDumper()->asArray($this->getRules());
    }

    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\Helper\RulesNormalizer;
12		use Yiisoft\Validator\Rule\Trait\SkipOnEmptyTrait;
13		use Yiisoft\Validator\Rule\Trait\SkipOnErrorTrait;
14		use Yiisoft\Validator\Rule\Trait\WhenTrait;
15		use Yiisoft\Validator\RuleInterface;
16		use Yiisoft\Validator\RulesDumper;
17		use Yiisoft\Validator\RuleWithOptionsInterface;
18		use Yiisoft\Validator\SkipOnEmptyInterface;
19		use Yiisoft\Validator\SkipOnErrorInterface;
20		use Yiisoft\Validator\WhenInterface;
21
22		/**
23		* Allows to combine and validate multiple rules.
24		*
25		* @psalm-import-type WhenType from WhenInterface
26		*/
27		#[Attribute(Attribute::TARGET_CLASS \| Attribute::TARGET_PROPERTY \| Attribute::IS_REPEATABLE)]
28		class Composite implements
29		RuleWithOptionsInterface,
30		SkipOnErrorInterface,
31		WhenInterface,
32		SkipOnEmptyInterface,
33	4	AfterInitAttributeEventInterface
34		{
35		use SkipOnEmptyTrait;
36		use SkipOnErrorTrait;
37		use WhenTrait;
38
39		/**
40		* @var iterable<int, RuleInterface>
41		*/
42		protected iterable $rules = [];
43
44		/**
45		* @var bool\|callable\|null
46		*/
47		protected $skipOnEmpty = null;
48
49	4	protected bool $skipOnError = false;
50
51		/**
52	1	* @psalm-var WhenType
53		*/
54	1	protected Closure\|null $when = null;
55
56		private ?RulesDumper $rulesDumper = null;
57	3
58		/**
59		* @param iterable<Closure\|RuleInterface> $rules
60		*
61		* @psalm-param WhenType $when
62		*/
63		public function __construct(
64		iterable $rules = [],
65	3	bool\|callable\|null $skipOnEmpty = null,
66	3	bool $skipOnError = false,
67	3	Closure\|null $when = null,
68		) {
69		$this->rules = RulesNormalizer::normalizeList($rules);
70		$this->skipOnEmpty = $skipOnEmpty;
71		$this->skipOnError = $skipOnError;
72		$this->when = $when;
73		}
74	2
75		public function getName(): string
76	2	{
77		return 'composite';
78		}
79	3
80		#[ArrayShape([
81	3	'skipOnEmpty' => 'bool',
82		'skipOnError' => 'bool',
83		'rules' => 'array',
84		])]
85		public function getOptions(): array
86		{
87		return [
88		'skipOnEmpty' => $this->getSkipOnEmptyOption(),
89		'skipOnError' => $this->skipOnError,
90		'rules' => $this->dumpRulesAsArray(),
91		];
92		}
93
94		/**
95		* @return iterable<int, RuleInterface>
96		*/
97		public function getRules(): iterable
98		{
99		return $this->rules;
100		}
101
102		final public function getHandlerClassName(): string
103		{
104		return CompositeHandler::class;
105		}
106
107		public function afterInitAttribute(object $object): void
108		{
109		foreach ($this->getRules() as $rule) {
110		if ($rule instanceof AfterInitAttributeEventInterface) {
111		$rule->afterInitAttribute($object);
112		}
113		}
114		}
115
116		final protected function dumpRulesAsArray(): array
117		{
118		return $this->getRulesDumper()->asArray($this->getRules());
119		}
120
121		private function getRulesDumper(): RulesDumper
122		{
123		if ($this->rulesDumper === null) {
124		$this->rulesDumper = new RulesDumper();
125		}
126
127		return $this->rulesDumper;
		0 ignored issues – show Bug Best Practice introduced 2022-12-07 07:53 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\RulesDumper`. Consider adding an additional type-check to rule them out. Loading history...
128		}
129		}
130

yiisoft / validator

Push — master ( c5e9e9...342519 )

Composite::getRules() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like