AbstractValidator::validate() - Code Metrics - Inspection of "Abstract validator" - spiral/framework - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#360)

by Valentin

created 2020-12-04 10:03 UTC

AbstractValidator::validate() B

↳ Parent: AbstractValidator

Complexity

Conditions	10
Paths	9

Size

Total Lines	29
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	10
eloc	15
c	1
b	0
f	0
nc	9
nop	0
dl	0
loc	29
rs	7.6666

How to fix Complexity

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Validation;

use Spiral\Validation\Exception\ValidationException;

abstract class AbstractValidator implements ValidatorInterface
{
    /** @var array */
    private $errors;

    /** @var array */
    private $rules;

    /** @var mixed */
    private $context;

    /** @var RulesInterface */
    private $provider;

    /**
     * @param array          $rules
     * @param mixed          $context
     * @param RulesInterface $ruleProvider
     */
    public function __construct(array $rules, $context, RulesInterface $ruleProvider)
    {
        $this->errors = [];
        $this->rules = $rules;
        $this->context = $context;
        $this->provider = $ruleProvider;
    }

    /**
     * Destruct the service.
     */
    public function __destruct()
    {
        $this->rules = [];
        $this->provider = null;
        $this->errors = [];
    }

    public function __clone()
    {
        $this->errors = [];
    }

    /**
     * @inheritdoc
     */
    public function withContext($context): ValidatorInterface
    {
        $validator = clone $this;
        $validator->context = $context;
        $validator->errors = [];

        return $validator;
    }

    /**
     * @inheritdoc
     */
    public function getContext()
    {
        return $this->context;
    }

    /**
     * @inheritdoc
     */
    public function isValid(): bool
    {
        return $this->getErrors() === [];
    }

    /**
     * @inheritdoc
     */
    public function getErrors(): array
    {
        $this->validate();

        return $this->errors;
    }

    /**
     * Check if value has any error associated.
     *
     * @param string $field
     *
     * @return bool
     */
    public function hasError(string $field): bool
    {
        return isset($this->getErrors()[$field]);
    }

    /**
     * Validate data over given rules and context.
     *
     * @throws ValidationException
     */
    final protected function validate(): void
    {
        if ($this->errors !== []) {
            // already validated
            return;
        }

        $this->errors = [];

        foreach ($this->rules as $field => $rules) {
            $hasValue = $this->hasValue($field);
            $value = $this->getValue($field);

            foreach ($this->provider->getRules($rules) as $rule) {
                if (!$hasValue && $rule->ignoreEmpty($value) && !$rule->hasConditions()) {
                    continue;
                }

                foreach ($rule->getConditions() as $condition) {
                    if (!$condition->isMet($this, $field, $value)) {
                        // condition is not met, skipping validation
                        continue 2;
                    }
                }

                if (!$rule->validate($this, $field, $value)) {
                    // got error, jump to next field
                    $this->errors[$field] = $rule->getMessage($field, $value);
                    break;
                }
            }
        }
    }
}


1			<?php
2
3			/**
4			* Spiral Framework.
5			*
6			* @license MIT
7			* @author Anton Titov (Wolfy-J)
8			*/
9
10			declare(strict_types=1);
11
12			namespace Spiral\Validation;
13
14			use Spiral\Validation\Exception\ValidationException;
15
16			abstract class AbstractValidator implements ValidatorInterface
17			{
18			/** @var array */
19			private $errors;
20
21			/** @var array */
22			private $rules;
23
24			/** @var mixed */
25			private $context;
26
27			/** @var RulesInterface */
28			private $provider;
29
30			/**
31			* @param array $rules
32			* @param mixed $context
33			* @param RulesInterface $ruleProvider
34			*/
35			public function __construct(array $rules, $context, RulesInterface $ruleProvider)
36			{
37			$this->errors = [];
38			$this->rules = $rules;
39			$this->context = $context;
40			$this->provider = $ruleProvider;
41			}
42
43			/**
44			* Destruct the service.
45			*/
46			public function __destruct()
47			{
48			$this->rules = [];
49			$this->provider = null;
50			$this->errors = [];
51			}
52
53			public function __clone()
54			{
55			$this->errors = [];
56			}
57
58			/**
59			* @inheritdoc
60			*/
61			public function withContext($context): ValidatorInterface
62			{
63			$validator = clone $this;
64			$validator->context = $context;
65			$validator->errors = [];
66
67			return $validator;
68			}
69
70			/**
71			* @inheritdoc
72			*/
73			public function getContext()
74			{
75			return $this->context;
76			}
77
78			/**
79			* @inheritdoc
80			*/
81			public function isValid(): bool
82			{
83			return $this->getErrors() === [];
84			}
85
86			/**
87			* @inheritdoc
88			*/
89			public function getErrors(): array
90			{
91			$this->validate();
92
93			return $this->errors;
94			}
95
96			/**
97			* Check if value has any error associated.
98			*
99			* @param string $field
100			*
101			* @return bool
102			*/
103			public function hasError(string $field): bool
104			{
105			return isset($this->getErrors()[$field]);
106			}
107
108			/**
109			* Validate data over given rules and context.
110			*
111			* @throws ValidationException
112			*/
113			final protected function validate(): void
114			{
115			if ($this->errors !== []) {
116			// already validated
117			return;
118			}
119
120			$this->errors = [];
121
122			foreach ($this->rules as $field => $rules) {
123			$hasValue = $this->hasValue($field);
124			$value = $this->getValue($field);
125
126			foreach ($this->provider->getRules($rules) as $rule) {
127			if (!$hasValue && $rule->ignoreEmpty($value) && !$rule->hasConditions()) {
128			continue;
129			}
130
131			foreach ($rule->getConditions() as $condition) {
132			if (!$condition->isMet($this, $field, $value)) {
133			// condition is not met, skipping validation
134			continue 2;
135			}
136			}
137
138			if (!$rule->validate($this, $field, $value)) {
139			// got error, jump to next field
140			$this->errors[$field] = $rule->getMessage($field, $value);
141			break;
142			}
143			}
144			}
145			}
146			}
147

spiral / framework

Pull Request — master (#360)

AbstractValidator::validate() B

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like