Rules::validate() - Code Metrics - Inspection of "Other usage of translator in validator (concept, d..." - yiisoft/validator - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#99)

by Def

created 2021-01-22 19:29 UTC

Rules::validate() A

↳ Parent: Rules

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

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

<?php

declare(strict_types=1);

namespace Yiisoft\Validator;

use Yiisoft\Validator\Rule\Callback;

/**
 * Rules represents multiple rules for a single value
 */
final class Rules
{
    /**
     * @var Rule[] $rules
     */
    private array $rules = [];

    public function __construct(iterable $rules = [])
    {
        foreach ($rules as $rule) {
            $this->add($rule);
        }
    }

    /**
     * @param callable|Rule $rule
     */
    public function add($rule): void
    {
        $this->rules[] = $this->normalizeRule($rule);
    }

    public function validate($value, DataSetInterface $dataSet = null, bool $previousRulesErrored = false): Result
    {
        $compoundResult = new Result();
        foreach ($this->rules as $rule) {
            $ruleResult = $rule->validate($value, $dataSet, $previousRulesErrored);
            if ($ruleResult->isValid() === false) {
                $previousRulesErrored = true;
                $compoundResult->addResult($ruleResult);
            }
        }
        return $compoundResult;
    }

    private function normalizeRule($rule): Rule
    {
        if (is_callable($rule)) {
            $rule = new Callback($rule);
        }

        if (!$rule instanceof Rule) {
            throw new \InvalidArgumentException('Rule should be either instance of Rule class or a callable');
        }

        return $rule;
    }

    /**
     * Return rules as array.
     *
     * @return array
     */
    public function asArray(?ErrorMessageFormatterInterface $formatter = null): array
    {
        $arrayOfRules = [];
        foreach ($this->rules as $rule) {
            $arrayOfRules[] = array_merge([$rule->getName()], $rule->getOptions($formatter));
        }
        return $arrayOfRules;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Yiisoft\Validator;
6
7		use Yiisoft\Validator\Rule\Callback;
8
9		/**
10		* Rules represents multiple rules for a single value
11		*/
12		final class Rules
13		{
14		/**
15		* @var Rule[] $rules
16		*/
17		private array $rules = [];
18
19	21	public function __construct(iterable $rules = [])
20		{
21	21	foreach ($rules as $rule) {
22	15	$this->add($rule);
23		}
24	21	}
25
26		/**
27		* @param callable\|Rule $rule
28		*/
29	21	public function add($rule): void
30		{
31	21	$this->rules[] = $this->normalizeRule($rule);
32	21	}
33
34	14	public function validate($value, DataSetInterface $dataSet = null, bool $previousRulesErrored = false): Result
35		{
36	14	$compoundResult = new Result();
37	14	foreach ($this->rules as $rule) {
38	14	$ruleResult = $rule->validate($value, $dataSet, $previousRulesErrored);
39	14	if ($ruleResult->isValid() === false) {
40	14	$previousRulesErrored = true;
41	14	$compoundResult->addResult($ruleResult);
42		}
43		}
44	14	return $compoundResult;
45		}
46
47	21	private function normalizeRule($rule): Rule
48		{
49	21	if (is_callable($rule)) {
50	3	$rule = new Callback($rule);
51		}
52
53	21	if (!$rule instanceof Rule) {
54		throw new \InvalidArgumentException('Rule should be either instance of Rule class or a callable');
55		}
56
57	21	return $rule;
58		}
59
60		/**
61		* Return rules as array.
62		*
63		* @return array
64		*/
65	6	public function asArray(?ErrorMessageFormatterInterface $formatter = null): array
66		{
67	6	$arrayOfRules = [];
68	6	foreach ($this->rules as $rule) {
69	6	$arrayOfRules[] = array_merge([$rule->getName()], $rule->getOptions($formatter));
70		}
71	6	return $arrayOfRules;
72		}
73		}
74

yiisoft / validator

Pull Request — master (#99)

Rules::validate() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like