ValidatorChain::__call() - Code Metrics - bluzphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

ValidatorChain::__call() A
last analyzed 2021-12-30 11:07 UTC

↳ Parent: ValidatorChain

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php

/**
 * Bluz Framework Component
 *
 * @copyright Bluz PHP Team
 * @link      https://github.com/bluzphp/framework
 */

declare(strict_types=1);

namespace Bluz\Validator;

use Bluz\Validator\Exception\ComponentException;
use Bluz\Validator\Exception\ValidatorException;
use Bluz\Validator\Rule\RequiredRule;
use Bluz\Validator\Rule\RuleInterface;

/**
 * Chain of Validators
 *
 * Chain can consists one or more validation rules
 *
 * @package  Bluz\Validator
 * @author   Anton Shevchuk
 *
 * @method ValidatorChain alpha($additionalCharacters = '')
 * @method ValidatorChain alphaNumeric($additionalCharacters = '')
 * @method ValidatorChain array($callback)
 * @method ValidatorChain between($min, $max)
 * @method ValidatorChain betweenInclusive($min, $max)
 * @method ValidatorChain condition($condition)
 * @method ValidatorChain contains($containsValue)
 * @method ValidatorChain containsStrict($containsValue)
 * @method ValidatorChain countryCode()
 * @method ValidatorChain creditCard()
 * @method ValidatorChain date($format)
 * @method ValidatorChain domain($checkDns = false)
 * @method ValidatorChain email($checkDns = false)
 * @method ValidatorChain equals($compareTo)
 * @method ValidatorChain equalsStrict($compareTo)
 * @method ValidatorChain float()
 * @method ValidatorChain in($haystack)
 * @method ValidatorChain inStrict($haystack)
 * @method ValidatorChain integer()
 * @method ValidatorChain ip($options = null)
 * @method ValidatorChain json()
 * @method ValidatorChain latin($additionalCharacters = '')
 * @method ValidatorChain latinNumeric($additionalCharacters = '')
 * @method ValidatorChain length($min = null, $max = null)
 * @method ValidatorChain less($maxValue)
 * @method ValidatorChain lessOrEqual($maxValue)
 * @method ValidatorChain more($minValue)
 * @method ValidatorChain moreOrEqual($minValue)
 * @method ValidatorChain notEmpty()
 * @method ValidatorChain noWhitespace()
 * @method ValidatorChain numeric()
 * @method ValidatorChain required()
 * @method ValidatorChain slug()
 * @method ValidatorChain string()
 */
class ValidatorChain implements ValidatorInterface
{
    /**
     * @var string description of rules chain
     */
    protected $description;

    /**
     * @var RuleInterface[] list of validation rules
     */
    protected $rules = [];

    /**
     * @var string Error message
     */
    protected $error;

    /**
     * Magic call for create new rule
     *
     * @param  string $ruleName
     * @param  array  $arguments
     *
     * @return ValidatorChain
     * @throws Exception\ComponentException
     */
    public function __call($ruleName, $arguments): ValidatorChain
    {
        $this->addRule(Validator::rule($ruleName, $arguments));
        return $this;
    }

    /**
     * Add Rule to ValidatorChain
     *
     * @param RuleInterface $rule
     *
     * @return ValidatorChain
     */
    public function addRule(RuleInterface $rule): ValidatorChain
    {
        $this->rules[] = $rule;
        return $this;
    }

    /**
     * Get required flag
     *
     * @return bool
     */
    public function isRequired(): bool
    {
        foreach ($this->rules as $rule) {
            if ($rule instanceof RequiredRule) {
                return true;
            }
        }
        return false;
    }

    /**
     * Add Callback Rule to ValidatorChain
     *
     * @param mixed       $callable
     * @param string|null $description
     *
     * @return ValidatorChain
     * @throws ComponentException
     */
    public function callback($callable, ?string $description = null): ValidatorChain
    {
        $rule = Validator::rule('callback', [$callable]);
        if (null !== $description) {
            $rule->setDescription($description);
        }
        $this->addRule($rule);
        return $this;
    }

    /**
     * Add Regexp Rule to ValidatorChain
     *
     * @param string $expression
     * @param string|null $description
     *
     * @return ValidatorChain
     * @throws ComponentException
     */
    public function regexp(string $expression, ?string $description = null): ValidatorChain
    {
        $rule = Validator::rule('regexp', [$expression]);
        if (null !== $description) {
            $rule->setDescription($description);
        }
        $this->addRule($rule);
        return $this;
    }

    /**
     * Validate chain of rules
     *
     * @param mixed $input
     *
     * @return bool
     */
    public function validate($input): bool
    {
        $this->error = null; // clean
        foreach ($this->rules as $rule) {
            if (!$rule->validate($input)) {
                // apply custom description or use description from rule
                $this->setError($this->description ?? $rule->getDescription());
                return false;
            }
        }
        return true;
    }

    /**
     * Assert
     *
     * @param  mixed $input
     *
     * @throws ValidatorException
     */
    public function assert($input): void
    {
        if (!$this->validate($input)) {
            throw new ValidatorException($this->getError());
        }
    }

    /**
     * @inheritdoc
     */
    public function __invoke($input): bool
    {
        return $this->validate($input);
    }

    /**
     * @inheritdoc
     */
    public function __toString(): string
    {
        return implode("\n", $this->getDescription());
    }

    /**
     * Get error message
     *
     * @return null|string
     */
    public function getError(): ?string
    {
        return $this->error;
    }

    /**
     * Set error message for replace text from rule
     *
     * @param string $message
     *
     * @return ValidatorChain
     */
    protected function setError(string $message): ValidatorChain
    {
        $this->error = $message;
        return $this;
    }

    /**
     * Get validation description
     *
     * @return array
     */
    public function getDescription(): array
    {
        // apply custom description
        if ($this->description) {
            return [$this->description];
        }

        // eject description from rules
        return array_map('\strval', $this->rules);
    }

    /**
     * Set validation description
     *
     * @param string $message
     *
     * @return ValidatorChain
     */
    public function setDescription(string $message): ValidatorChain
    {
        $this->description = $message;
        return $this;
    }
}


1		<?php
2
3		/**
4		* Bluz Framework Component
5		*
6		* @copyright Bluz PHP Team
7		* @link https://github.com/bluzphp/framework
8		*/
9
10		declare(strict_types=1);
11
12		namespace Bluz\Validator;
13
14		use Bluz\Validator\Exception\ComponentException;
15		use Bluz\Validator\Exception\ValidatorException;
16		use Bluz\Validator\Rule\RequiredRule;
17		use Bluz\Validator\Rule\RuleInterface;
18
19		/**
20		* Chain of Validators
21		*
22		* Chain can consists one or more validation rules
23		*
24		* @package Bluz\Validator
25		* @author Anton Shevchuk
26		*
27		* @method ValidatorChain alpha($additionalCharacters = '')
28		* @method ValidatorChain alphaNumeric($additionalCharacters = '')
29		* @method ValidatorChain array($callback)
30		* @method ValidatorChain between($min, $max)
31		* @method ValidatorChain betweenInclusive($min, $max)
32		* @method ValidatorChain condition($condition)
33		* @method ValidatorChain contains($containsValue)
34		* @method ValidatorChain containsStrict($containsValue)
35		* @method ValidatorChain countryCode()
36		* @method ValidatorChain creditCard()
37		* @method ValidatorChain date($format)
38		* @method ValidatorChain domain($checkDns = false)
39		* @method ValidatorChain email($checkDns = false)
40		* @method ValidatorChain equals($compareTo)
41		* @method ValidatorChain equalsStrict($compareTo)
42		* @method ValidatorChain float()
43		* @method ValidatorChain in($haystack)
44		* @method ValidatorChain inStrict($haystack)
45		* @method ValidatorChain integer()
46		* @method ValidatorChain ip($options = null)
47		* @method ValidatorChain json()
48		* @method ValidatorChain latin($additionalCharacters = '')
49		* @method ValidatorChain latinNumeric($additionalCharacters = '')
50		* @method ValidatorChain length($min = null, $max = null)
51		* @method ValidatorChain less($maxValue)
52		* @method ValidatorChain lessOrEqual($maxValue)
53		* @method ValidatorChain more($minValue)
54		* @method ValidatorChain moreOrEqual($minValue)
55		* @method ValidatorChain notEmpty()
56		* @method ValidatorChain noWhitespace()
57		* @method ValidatorChain numeric()
58		* @method ValidatorChain required()
59		* @method ValidatorChain slug()
60		* @method ValidatorChain string()
61		*/
62		class ValidatorChain implements ValidatorInterface
63		{
64		/**
65		* @var string description of rules chain
66		*/
67		protected $description;
68
69		/**
70		* @var RuleInterface[] list of validation rules
71		*/
72		protected $rules = [];
73
74		/**
75		* @var string Error message
76		*/
77		protected $error;
78
79		/**
80		* Magic call for create new rule
81		*
82		* @param string $ruleName
83		* @param array $arguments
84		*
85		* @return ValidatorChain
86		* @throws Exception\ComponentException
87		*/
88	13	public function __call($ruleName, $arguments): ValidatorChain
89		{
90	13	$this->addRule(Validator::rule($ruleName, $arguments));
91	12	return $this;
92		}
93
94		/**
95		* Add Rule to ValidatorChain
96		*
97		* @param RuleInterface $rule
98		*
99		* @return ValidatorChain
100		*/
101	21	public function addRule(RuleInterface $rule): ValidatorChain
102		{
103	21	$this->rules[] = $rule;
104	21	return $this;
105		}
106
107		/**
108		* Get required flag
109		*
110		* @return bool
111		*/
112	3	public function isRequired(): bool
113		{
114	3	foreach ($this->rules as $rule) {
115	3	if ($rule instanceof RequiredRule) {
116	3	return true;
117		}
118		}
119	2	return false;
120		}
121
122		/**
123		* Add Callback Rule to ValidatorChain
124		*
125		* @param mixed $callable
126		* @param string\|null $description
127		*
128		* @return ValidatorChain
129		* @throws ComponentException
130		*/
131	10	public function callback($callable, ?string $description = null): ValidatorChain
132		{
133	10	$rule = Validator::rule('callback', [$callable]);
134	10	if (null !== $description) {
135	3	$rule->setDescription($description);
136		}
137	10	$this->addRule($rule);
138	10	return $this;
139		}
140
141		/**
142		* Add Regexp Rule to ValidatorChain
143		*
144		* @param string $expression
145		* @param string\|null $description
146		*
147		* @return ValidatorChain
148		* @throws ComponentException
149		*/
150	1	public function regexp(string $expression, ?string $description = null): ValidatorChain
151		{
152	1	$rule = Validator::rule('regexp', [$expression]);
153	1	if (null !== $description) {
154	1	$rule->setDescription($description);
155		}
156	1	$this->addRule($rule);
157	1	return $this;
158		}
159
160		/**
161		* Validate chain of rules
162		*
163		* @param mixed $input
164		*
165		* @return bool
166		*/
167	15	public function validate($input): bool
168		{
169	15	$this->error = null; // clean
170	15	foreach ($this->rules as $rule) {
171	15	if (!$rule->validate($input)) {
172		// apply custom description or use description from rule
173	9	$this->setError($this->description ?? $rule->getDescription());
174	9	return false;
175		}
176		}
177	7	return true;
178		}
179
180		/**
181		* Assert
182		*
183		* @param mixed $input
184		*
185		* @throws ValidatorException
186		*/
187	3	public function assert($input): void
188		{
189	3	if (!$this->validate($input)) {
190	3	throw new ValidatorException($this->getError());
191		}
192		}
193
194		/**
195		* @inheritdoc
196		*/
197	2	public function __invoke($input): bool
198		{
199	2	return $this->validate($input);
200		}
201
202		/**
203		* @inheritdoc
204		*/
205	1	public function __toString(): string
206		{
207	1	return implode("\n", $this->getDescription());
208		}
209
210		/**
211		* Get error message
212		*
213		* @return null\|string
214		*/
215	8	public function getError(): ?string
216		{
217	8	return $this->error;
218		}
219
220		/**
221		* Set error message for replace text from rule
222		*
223		* @param string $message
224		*
225		* @return ValidatorChain
226		*/
227	9	protected function setError(string $message): ValidatorChain
228		{
229	9	$this->error = $message;
230	9	return $this;
231		}
232
233		/**
234		* Get validation description
235		*
236		* @return array
237		*/
238	5	public function getDescription(): array
239		{
240		// apply custom description
241	5	if ($this->description) {
242	2	return [$this->description];
243		}
244
245		// eject description from rules
246	4	return array_map('\strval', $this->rules);
247		}
248
249		/**
250		* Set validation description
251		*
252		* @param string $message
253		*
254		* @return ValidatorChain
255		*/
256	4	public function setDescription(string $message): ValidatorChain
257		{
258	4	$this->description = $message;
259	4	return $this;
260		}
261		}
262

bluzphp / framework

ValidatorChain::__call() A last analyzed 2021-12-30 11:07 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

ValidatorChain::__call() A
last analyzed 2021-12-30 11:07 UTC