Chain::each() - Code Metrics - Inspection of "Add Hash validation rule (#122)" - particle-php/Validator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 115690...6ac2d3 )

by Rick

created 2016-08-06 10:27 UTC

Chain::each() A

↳ Parent: Chain

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes	1
Bugs	0	Features	0

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

<?php
/**
 * Particle.
 *
 * @link      http://github.com/particle-php for the canonical source repository
 * @copyright Copyright (c) 2005-2016 Particle (http://particle-php.com)
 * @license   https://github.com/particle-php/validator/blob/master/LICENSE New BSD License
 */
namespace Particle\Validator;

use Particle\Validator\Output\Structure;
use Particle\Validator\Output\Subject;
use Particle\Validator\Value\Container;

/**
 * Represents a collection of Rules which may break the chain of validation (but usually don't).
 *
 * @package Particle\Validator
 */
class Chain
{
    /**
     * The key we want to validate.
     *
     * @var string
     */
    protected $key;

    /**
     * The name that we can use in error messages.
     *
     * @var string
     */
    protected $name;

    /**
     * The array of all rules for this chain.
     *
     * @var Rule[]
     */
    protected $rules = [];

    /**
     * The message stack to append messages to.
     *
     * @var MessageStack
     */
    protected $messageStack;

    /**
     * Construct the chain.
     *
     * @param string $key
     * @param string $name
     * @param bool $required
     * @param bool $allowEmpty
     */
    public function __construct($key, $name, $required, $allowEmpty)
    {
        $this->key = $key;
        $this->name = $name;

        $this->addRule(new Rule\Required($required));
        $this->addRule(new Rule\NotEmpty($allowEmpty));
    }

    /**
     * Overwrite the default __clone behaviour to make sure the rules are cloned too.
     */
    public function __clone()
    {
        $rules = [];
        foreach ($this->rules as $rule) {
            $rules[] = clone $rule;
        }
        $this->rules = $rules;
    }

    /**
     * Validate the value to consist only out of alphanumeric characters.
     *
     * @param bool $allowWhitespace
     * @return $this
     */
    public function alnum($allowWhitespace = false)
    {
        return $this->addRule(new Rule\Alnum($allowWhitespace));
    }

    /**
     * Validate that the value only consists our of alphabetic characters.
     *
     * @param bool $allowWhitespace
     * @return $this
     */
    public function alpha($allowWhitespace = false)
    {
        return $this->addRule(new Rule\Alpha($allowWhitespace));
    }

    /**
     * Validate that the value is between $min and $max (inclusive).
     *
     * @param int $min
     * @param int $max
     * @return $this
     */
    public function between($min, $max)
    {
        return $this->addRule(new Rule\Between($min, $max));
    }

    /**
     * Validate that the value is a boolean.
     *
     * @return $this
     */
    public function bool()
    {
        return $this->addRule(new Rule\Boolean());
    }

    /**
     * Validate by executing a callback function, and returning its result.
     *
     * @param callable $callable
     * @return $this
     */
    public function callback(callable $callable)
    {
        return $this->addRule(new Rule\Callback($callable));
    }

    /**
     * Validates that the value is a valid credit card number.
     * @return $this
     */
    public function creditCard()
    {
        return $this->addRule(new Rule\CreditCard());
    }

    /**
     * Validates that the value is a date. If format is passed, it *must* be in that format.
     *
     * @param string|null $format
     * @return $this
     */
    public function datetime($format = null)
    {
        return $this->addRule(new Rule\Datetime($format));
    }

    /**
     * Validates that all characters of the value are decimal digits.
     *
     * @return $this
     */
    public function digits()
    {
        return $this->addRule(new Rule\Digits());
    }

    /**
     * Validates a value to be a nested array, which can then be validated using a new Validator instance.
     *
     * @param callable $callback
     * @return $this
     */
    public function each(callable $callback)
    {
        return $this->addRule(new Rule\Each($callback));
    }

    /**
     * Validates that the value is a valid email address (format only).
     * @return $this
     */
    public function email()
    {
        return $this->addRule(new Rule\Email());
    }

    /**
     * Validates that the value is equal to $value.
     *
     * @param string $value
     * @return $this
     */
    public function equals($value)
    {
        return $this->addRule(new Rule\Equal($value));
    }

    /**
     * Validates that the value represents a float.
     *
     * @return $this
     */
    public function float()
    {
        return $this->addRule(new Rule\IsFloat());
    }

    /**
     * Validates that the value is greater than $value.
     *
     * @param int $value
     * @return $this
     */
    public function greaterThan($value)
    {
        return $this->addRule(new Rule\GreaterThan($value));
    }

    /**
     * Validates that the value is in the array with optional "loose" checking.
     *
     * @param string $hashAlgorithm
     * @param bool $allowUppercase
     * @return $this
     * @see \Particle\Validator\Rule\Hash
     */
    public function hash($hashAlgorithm, $allowUppercase = false)
    {
        return $this->addRule(new Rule\Hash($hashAlgorithm, $allowUppercase));
    }

    /**
     * Validates that the value is in the array with optional "loose" checking.
     *
     * @param array $array
     * @param bool $strict
     * @return $this
     */
    public function inArray(array $array, $strict = true)
    {
        return $this->addRule(new Rule\InArray($array, $strict));
    }

    /**
     * Validates the value represents a valid integer
     *
     * @param bool $strict
     * @return $this
     * @see \Particle\Validator\Rule\Integer
     */
    public function integer($strict = false)
    {
        return $this->addRule(new Rule\Integer($strict));
    }

    /**
     * Validates the value is an array
     *
     * @return $this
     * @see \Particle\Validator\Rule\IsArray
     */
    public function isArray()
    {
        return $this->addRule(new Rule\IsArray());
    }

    /**
     * Validates that the value represents a valid JSON string
     *
     * @return $this
     * @see \Particle\Validator\Rule\Json
     */
    public function json()
    {
        return $this->addRule(new Rule\Json());
    }

    /**
     * Validate the value to be of precisely length $length.
     *
     * @param int $length
     * @return $this
     */
    public function length($length)
    {
        return $this->addRule(new Rule\Length($length));
    }

    /**
     * Validates that the length of the value is between $min and $max.
     *
     * If $max is null, it has no upper limit. The default is inclusive.
     *
     * @param int $min
     * @param int|null $max
     * @return $this
     */
    public function lengthBetween($min, $max)
    {
        return $this->addRule(new Rule\LengthBetween($min, $max));
    }

    /**
     * Validates that the value is less than $value.
     *
     * @param int $value
     * @return $this
     */
    public function lessThan($value)
    {
        return $this->addRule(new Rule\LessThan($value));
    }

    /**
     * Mount a rule object onto this chain.
     *
     * @param Rule $rule
     * @return $this
     */
    public function mount(Rule $rule)
    {
        return $this->addRule($rule);
    }

    /**
     * Validates that the value is either a integer or a float.
     *
     * @return $this
     */
    public function numeric()
    {
        return $this->addRule(new Rule\Numeric());
    }

    /**
     * Validates that the value is a valid phone number for $countryCode.
     *
     * @param string $countryCode
     * @see \Particle\Validator\Rule\Phone
     * @return $this
     */
    public function phone($countryCode)
    {
        return $this->addRule(new Rule\Phone($countryCode));
    }

    /**
     * Validates that the value matches the regular expression $regex.
     *
     * @param string $regex
     * @return $this
     */
    public function regex($regex)
    {
        return $this->addRule(new Rule\Regex($regex));
    }

    /**
     * Validates that the value represents a string.
     *
     * @return $this
     */
    public function string()
    {
        return $this->addRule(new Rule\IsString());
    }

    /**
     * Validates that the value is a valid URL. The schemes array is to selectively whitelist URL schemes.
     *
     * @param array $schemes
     * @return $this
     */
    public function url(array $schemes = [])
    {
        return $this->addRule(new Rule\Url($schemes));
    }

    /**
     * Validates that the value is a valid UUID
     *
     * @param int $version
     * @return $this
     */
    public function uuid($version = Rule\Uuid::UUID_V4)
    {
        return $this->addRule(new Rule\Uuid($version));
    }

    /**
     * Set a callable or boolean value which may be used to alter the required requirement on validation time.
     *
     * This may be incredibly helpful when doing conditional validation.
     *
     * @param callable|bool $required
     * @return $this
     */
    public function required($required)
    {
        $this->getRequiredRule()->setRequired($required);
        return $this;
    }

    /**
     * Set a callable or boolean value which may be used to alter the allow empty requirement on validation time.
     *
     * This may be incredibly helpful when doing conditional validation.
     *
     * @param callable|bool $allowEmpty
     * @return $this
     */
    public function allowEmpty($allowEmpty)
    {
        $this->getNotEmptyRule()->setAllowEmpty($allowEmpty);
        return $this;
    }

    /**
     * Attach a representation of this Chain to the Output\Structure $structure.
     *
     * @internal
     * @param Structure $structure
     * @param MessageStack $messageStack
     * @return Structure
     */
    public function output(Structure $structure, MessageStack $messageStack)
    {
        $subject = new Subject($this->key, $this->name);

        foreach ($this->rules as $rule) {
            $rule->output($subject, $messageStack);
        }

        $structure->addSubject($subject);

        return $structure;
    }

    /**
     * Validates the values in the $values array and appends messages to $messageStack. Returns the result as a bool.
     *
     * @param MessageStack $messageStack
     * @param Container $input
     * @param Container $output
     * @return bool
     */
    public function validate(MessageStack $messageStack, Container $input, Container $output)
    {
        $valid = true;
        foreach ($this->rules as $rule) {
            $rule->setMessageStack($messageStack);
            $rule->setParameters($this->key, $this->name);

            $valid = $rule->isValid($this->key, $input) && $valid;

            if ($rule->shouldBreakChain()) {
                break;
            }
        }

        if ($valid && $input->has($this->key)) {
            $output->set($this->key, $input->get($this->key));
        }
        return $valid;
    }

    /**
     * Shortcut method for storing a rule on this chain, and returning the chain.
     *
     * @param Rule $rule
     * @return $this
     */
    protected function addRule(Rule $rule)
    {
        $this->rules[] = $rule;

        return $this;
    }

    /**
     * Returns the first rule, which is always the required rule.
     *
     * @return Rule\Required
     */
    protected function getRequiredRule()
    {
        return $this->rules[0];
    }

    /**
     * Returns the second rule, which is always the allow empty rule.
     *
     * @return Rule\NotEmpty
     */
    protected function getNotEmptyRule()
    {
        return $this->rules[1];
    }
}


1		<?php
2		/**
3		* Particle.
4		*
5		* @link http://github.com/particle-php for the canonical source repository
6		* @copyright Copyright (c) 2005-2016 Particle (http://particle-php.com)
7		* @license https://github.com/particle-php/validator/blob/master/LICENSE New BSD License
8		*/
9		namespace Particle\Validator;
10
11		use Particle\Validator\Output\Structure;
12		use Particle\Validator\Output\Subject;
13		use Particle\Validator\Value\Container;
14
15		/**
16		* Represents a collection of Rules which may break the chain of validation (but usually don't).
17		*
18		* @package Particle\Validator
19		*/
20		class Chain
21		{
22		/**
23		* The key we want to validate.
24		*
25		* @var string
26		*/
27		protected $key;
28
29		/**
30		* The name that we can use in error messages.
31		*
32		* @var string
33		*/
34		protected $name;
35
36		/**
37		* The array of all rules for this chain.
38		*
39		* @var Rule[]
40		*/
41		protected $rules = [];
42
43		/**
44		* The message stack to append messages to.
45		*
46		* @var MessageStack
47		*/
48		protected $messageStack;
49
50		/**
51		* Construct the chain.
52		*
53		* @param string $key
54		* @param string $name
55		* @param bool $required
56		* @param bool $allowEmpty
57		*/
58	219	public function __construct($key, $name, $required, $allowEmpty)
59		{
60	219	$this->key = $key;
61	219	$this->name = $name;
62
63	219	$this->addRule(new Rule\Required($required));
64	219	$this->addRule(new Rule\NotEmpty($allowEmpty));
65	219	}
66
67		/**
68		* Overwrite the default __clone behaviour to make sure the rules are cloned too.
69		*/
70	3	public function __clone()
71		{
72	3	$rules = [];
73	3	foreach ($this->rules as $rule) {
74	3	$rules[] = clone $rule;
75	3	}
76	3	$this->rules = $rules;
77	3	}
78
79		/**
80		* Validate the value to consist only out of alphanumeric characters.
81		*
82		* @param bool $allowWhitespace
83		* @return $this
84		*/
85	7	public function alnum($allowWhitespace = false)
86		{
87	7	return $this->addRule(new Rule\Alnum($allowWhitespace));
88		}
89
90		/**
91		* Validate that the value only consists our of alphabetic characters.
92		*
93		* @param bool $allowWhitespace
94		* @return $this
95		*/
96	7	public function alpha($allowWhitespace = false)
97		{
98	7	return $this->addRule(new Rule\Alpha($allowWhitespace));
99		}
100
101		/**
102		* Validate that the value is between $min and $max (inclusive).
103		*
104		* @param int $min
105		* @param int $max
106		* @return $this
107		*/
108	6	public function between($min, $max)
109		{
110	6	return $this->addRule(new Rule\Between($min, $max));
111		}
112
113		/**
114		* Validate that the value is a boolean.
115		*
116		* @return $this
117		*/
118	9	public function bool()
119		{
120	9	return $this->addRule(new Rule\Boolean());
121		}
122
123		/**
124		* Validate by executing a callback function, and returning its result.
125		*
126		* @param callable $callable
127		* @return $this
128		*/
129	5	public function callback(callable $callable)
130		{
131	5	return $this->addRule(new Rule\Callback($callable));
132		}
133
134		/**
135		* Validates that the value is a valid credit card number.
136		* @return $this
137		*/
138	15	public function creditCard()
139		{
140	15	return $this->addRule(new Rule\CreditCard());
141		}
142
143		/**
144		* Validates that the value is a date. If format is passed, it must be in that format.
145		*
146		* @param string\|null $format
147		* @return $this
148		*/
149	8	public function datetime($format = null)
150		{
151	8	return $this->addRule(new Rule\Datetime($format));
152		}
153
154		/**
155		* Validates that all characters of the value are decimal digits.
156		*
157		* @return $this
158		*/
159	4	public function digits()
160		{
161	4	return $this->addRule(new Rule\Digits());
162		}
163
164		/**
165		* Validates a value to be a nested array, which can then be validated using a new Validator instance.
166		*
167		* @param callable $callback
168		* @return $this
169		*/
170	5	public function each(callable $callback)
171		{
172	5	return $this->addRule(new Rule\Each($callback));
173		}
174
175		/**
176		* Validates that the value is a valid email address (format only).
177		* @return $this
178		*/
179	6	public function email()
180		{
181	6	return $this->addRule(new Rule\Email());
182		}
183
184		/**
185		* Validates that the value is equal to $value.
186		*
187		* @param string $value
188		* @return $this
189		*/
190	2	public function equals($value)
191		{
192	2	return $this->addRule(new Rule\Equal($value));
193		}
194
195		/**
196		* Validates that the value represents a float.
197		*
198		* @return $this
199		*/
200	6	public function float()
201		{
202	6	return $this->addRule(new Rule\IsFloat());
203		}
204
205		/**
206		* Validates that the value is greater than $value.
207		*
208		* @param int $value
209		* @return $this
210		*/
211	3	public function greaterThan($value)
212		{
213	3	return $this->addRule(new Rule\GreaterThan($value));
214		}
215
216		/**
217		* Validates that the value is in the array with optional "loose" checking.
218		*
219		* @param string $hashAlgorithm
220		* @param bool $allowUppercase
221		* @return $this
222		* @see \Particle\Validator\Rule\Hash
223		*/
224	12	public function hash($hashAlgorithm, $allowUppercase = false)
225		{
226	12	return $this->addRule(new Rule\Hash($hashAlgorithm, $allowUppercase));
227		}
228
229		/**
230		* Validates that the value is in the array with optional "loose" checking.
231		*
232		* @param array $array
233		* @param bool $strict
234		* @return $this
235		*/
236	4	public function inArray(array $array, $strict = true)
237		{
238	4	return $this->addRule(new Rule\InArray($array, $strict));
239		}
240
241		/**
242		* Validates the value represents a valid integer
243		*
244		* @param bool $strict
245		* @return $this
246		* @see \Particle\Validator\Rule\Integer
247		*/
248	18	public function integer($strict = false)
249		{
250	18	return $this->addRule(new Rule\Integer($strict));
251		}
252
253		/**
254		* Validates the value is an array
255		*
256		* @return $this
257		* @see \Particle\Validator\Rule\IsArray
258		*/
259	7	public function isArray()
260		{
261	7	return $this->addRule(new Rule\IsArray());
262		}
263
264		/**
265		* Validates that the value represents a valid JSON string
266		*
267		* @return $this
268		* @see \Particle\Validator\Rule\Json
269		*/
270	11	public function json()
271		{
272	11	return $this->addRule(new Rule\Json());
273		}
274
275		/**
276		* Validate the value to be of precisely length $length.
277		*
278		* @param int $length
279		* @return $this
280		*/
281	13	public function length($length)
282		{
283	13	return $this->addRule(new Rule\Length($length));
284		}
285
286		/**
287		* Validates that the length of the value is between $min and $max.
288		*
289		* If $max is null, it has no upper limit. The default is inclusive.
290		*
291		* @param int $min
292		* @param int\|null $max
293		* @return $this
294		*/
295	7	public function lengthBetween($min, $max)
296		{
297	7	return $this->addRule(new Rule\LengthBetween($min, $max));
298		}
299
300		/**
301		* Validates that the value is less than $value.
302		*
303		* @param int $value
304		* @return $this
305		*/
306	3	public function lessThan($value)
307		{
308	3	return $this->addRule(new Rule\LessThan($value));
309		}
310
311		/**
312		* Mount a rule object onto this chain.
313		*
314		* @param Rule $rule
315		* @return $this
316		*/
317	1	public function mount(Rule $rule)
318		{
319	1	return $this->addRule($rule);
320		}
321
322		/**
323		* Validates that the value is either a integer or a float.
324		*
325		* @return $this
326		*/
327	11	public function numeric()
328		{
329	11	return $this->addRule(new Rule\Numeric());
330		}
331
332		/**
333		* Validates that the value is a valid phone number for $countryCode.
334		*
335		* @param string $countryCode
336		* @see \Particle\Validator\Rule\Phone
337		* @return $this
338		*/
339	13	public function phone($countryCode)
340		{
341	13	return $this->addRule(new Rule\Phone($countryCode));
342		}
343
344		/**
345		* Validates that the value matches the regular expression $regex.
346		*
347		* @param string $regex
348		* @return $this
349		*/
350	2	public function regex($regex)
351		{
352	2	return $this->addRule(new Rule\Regex($regex));
353		}
354
355		/**
356		* Validates that the value represents a string.
357		*
358		* @return $this
359		*/
360	5	public function string()
361		{
362	5	return $this->addRule(new Rule\IsString());
363		}
364
365		/**
366		* Validates that the value is a valid URL. The schemes array is to selectively whitelist URL schemes.
367		*
368		* @param array $schemes
369		* @return $this
370		*/
371	7	public function url(array $schemes = [])
372		{
373	7	return $this->addRule(new Rule\Url($schemes));
374		}
375
376		/**
377		* Validates that the value is a valid UUID
378		*
379		* @param int $version
380		* @return $this
381		*/
382	12	public function uuid($version = Rule\Uuid::UUID_V4)
383		{
384	12	return $this->addRule(new Rule\Uuid($version));
385		}
386
387		/**
388		* Set a callable or boolean value which may be used to alter the required requirement on validation time.
389		*
390		* This may be incredibly helpful when doing conditional validation.
391		*
392		* @param callable\|bool $required
393		* @return $this
394		*/
395	5	public function required($required)
396		{
397	5	$this->getRequiredRule()->setRequired($required);
398	5	return $this;
399		}
400
401		/**
402		* Set a callable or boolean value which may be used to alter the allow empty requirement on validation time.
403		*
404		* This may be incredibly helpful when doing conditional validation.
405		*
406		* @param callable\|bool $allowEmpty
407		* @return $this
408		*/
409	11	public function allowEmpty($allowEmpty)
410		{
411	11	$this->getNotEmptyRule()->setAllowEmpty($allowEmpty);
412	11	return $this;
413		}
414
415		/**
416		* Attach a representation of this Chain to the Output\Structure $structure.
417		*
418		* @internal
419		* @param Structure $structure
420		* @param MessageStack $messageStack
421		* @return Structure
422		*/
423	2	public function output(Structure $structure, MessageStack $messageStack)
424		{
425	2	$subject = new Subject($this->key, $this->name);
426
427	2	foreach ($this->rules as $rule) {
428	2	$rule->output($subject, $messageStack);
429	2	}
430
431	2	$structure->addSubject($subject);
432
433	2	return $structure;
434		}
435
436		/**
437		* Validates the values in the $values array and appends messages to $messageStack. Returns the result as a bool.
438		*
439		* @param MessageStack $messageStack
440		* @param Container $input
441		* @param Container $output
442		* @return bool
443		*/
444	216	public function validate(MessageStack $messageStack, Container $input, Container $output)
445		{
446	216	$valid = true;
447	216	foreach ($this->rules as $rule) {
448	216	$rule->setMessageStack($messageStack);
449	216	$rule->setParameters($this->key, $this->name);
450
451	216	$valid = $rule->isValid($this->key, $input) && $valid;
452
453	216	if ($rule->shouldBreakChain()) {
454	17	break;
455		}
456	216	}
457
458	216	if ($valid && $input->has($this->key)) {
459	110	$output->set($this->key, $input->get($this->key));
460	110	}
461	216	return $valid;
462		}
463
464		/**
465		* Shortcut method for storing a rule on this chain, and returning the chain.
466		*
467		* @param Rule $rule
468		* @return $this
469		*/
470	219	protected function addRule(Rule $rule)
471		{
472	219	$this->rules[] = $rule;
473
474	219	return $this;
475		}
476
477		/**
478		* Returns the first rule, which is always the required rule.
479		*
480		* @return Rule\Required
481		*/
482	5	protected function getRequiredRule()
483		{
484	5	return $this->rules[0];
485		}
486
487		/**
488		* Returns the second rule, which is always the allow empty rule.
489		*
490		* @return Rule\NotEmpty
491		*/
492	11	protected function getNotEmptyRule()
493		{
494	11	return $this->rules[1];
495		}
496		}
497

particle-php / Validator

GitHub Access Token became invalid

Push — master ( 115690...6ac2d3 )

Chain::each() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like