NotEmpty::allowEmpty() - Code Metrics - Inspection of "Array support for IsEmpty rule" - particle-php/Validator - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#117)

by Carlos

created 2016-02-17 08:53 UTC

NotEmpty::allowEmpty() A

↳ Parent: NotEmpty

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes	3
Bugs	0	Features	0

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

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

use Particle\Validator\StringifyCallbackTrait;
use Particle\Validator\Rule;
use Particle\Validator\Value\Container;

/**
 * This class is responsible for checking if a certain key has a value.
 *
 * @package Particle\Validator\Rule
 */
class NotEmpty extends Rule
{
    use StringifyCallbackTrait;

    /**
     * The error code for when a value is empty while this is not allowed.
     */
    const EMPTY_VALUE = 'NotEmpty::EMPTY_VALUE';

    /**
     * The templates for the possible messages this validator can return.
     *
     * @var array
     */
    protected $messageTemplates = [
        self::EMPTY_VALUE => '{{ name }} must not be empty',
    ];

    /**
     * Denotes whether or not the chain should be stopped after this rule.
     *
     * @var bool
     */
    protected $shouldBreak;

    /**
     * Indicates if the value can be empty.
     *
     * @var bool
     */
    protected $allowEmpty;

    /**
     * Optionally contains a callable to overwrite the allow empty requirement on time of validation.
     *
     * @var callable
     */
    protected $allowEmptyCallback;

    /**
     * Contains the input container.
     *
     * @var Container
     */
    protected $input;

    /**
     * Construct the NotEmpty validator.
     *
     * @param bool $allowEmpty
     */
    public function __construct($allowEmpty)
    {
        $this->allowEmpty = (bool) $allowEmpty;
    }

    /**
     * @return bool
     */
    public function shouldBreakChain()
    {
        return $this->shouldBreak;
    }

    /**
     * Ensures a certain key has a value.
     *
     * @param mixed $value
     * @return bool
     */
    public function validate($value)
    {
        if ($this->isEmpty($value)) {
            $this->shouldBreak = true;

            return !$this->allowEmpty($this->input) ? $this->error(self::EMPTY_VALUE) : true;
        }
        return true;
    }

    /**
     * Determines whether or not value $value is to be considered "empty".
     *
     * @param mixed $value
     * @return bool
     */
    protected function isEmpty($value)
    {
        return
            (is_string($value) && strlen($value) === 0) ||
            $value === null ||
            (is_array($value) && count($value) === 0);
    }

    /**
     * @inheritdoc
     *
     * @param string $key
     * @param Container $input
     * @return bool
     */
    public function isValid($key, Container $input)
    {
        $this->input = $input;

        return $this->validate($input->get($key));
    }

    /**
     * Set a callable or boolean value to potentially alter the allow empty requirement at the time of validation.
     *
     * This may be incredibly useful for conditional validation.
     *
     * @param callable|bool $allowEmpty
     * @return $this
     */
    public function setAllowEmpty($allowEmpty)
    {
        if (is_callable($allowEmpty)) {
            return $this->setAllowEmptyCallback($allowEmpty);
        }
        return $this->overwriteAllowEmpty($allowEmpty);
    }

    /**
     * {@inheritdoc}
     */
    protected function getMessageParameters()
    {
        return array_merge(parent::getMessageParameters(), [
            'allowEmpty' => $this->allowEmpty,
            'callback' => $this->getCallbackAsString($this->allowEmptyCallback)
        ]);
    }

    /**
     * Overwrite the allow empty requirement after instantiation of this rule.
     *
     * @param bool $allowEmpty
     * @return $this
     */
    protected function overwriteAllowEmpty($allowEmpty)
    {
        $this->allowEmpty = $allowEmpty;
        return $this;
    }

    /**
     * Set the callback to execute to determine whether or not the rule should allow empty.
     *
     * @param callable $allowEmptyCallback
     * @return $this
     */
    protected function setAllowEmptyCallback(callable $allowEmptyCallback)
    {
        $this->allowEmptyCallback = $allowEmptyCallback;
        return $this;
    }

    /**
     * Determines whether or not the value may be empty.
     *
     * @param Container $input
     * @return bool
     */
    protected function allowEmpty(Container $input)
    {
        if (isset($this->allowEmptyCallback)) {
            $this->allowEmpty = call_user_func($this->allowEmptyCallback, $input->getArrayCopy());
        }
        return $this->allowEmpty;
    }
}


1		<?php
2		/**
3		* Particle.
4		*
5		* @link http://github.com/particle-php for the canonical source repository
6		* @copyright Copyright (c) 2005-2015 Particle (http://particle-php.com)
7		* @license https://github.com/particle-php/validator/blob/master/LICENSE New BSD License
8		*/
9		namespace Particle\Validator\Rule;
10
11		use Particle\Validator\StringifyCallbackTrait;
12		use Particle\Validator\Rule;
13		use Particle\Validator\Value\Container;
14
15		/**
16		* This class is responsible for checking if a certain key has a value.
17		*
18		* @package Particle\Validator\Rule
19		*/
20		class NotEmpty extends Rule
21		{
22		use StringifyCallbackTrait;
23
24		/**
25		* The error code for when a value is empty while this is not allowed.
26		*/
27		const EMPTY_VALUE = 'NotEmpty::EMPTY_VALUE';
28
29		/**
30		* The templates for the possible messages this validator can return.
31		*
32		* @var array
33		*/
34		protected $messageTemplates = [
35		self::EMPTY_VALUE => '{{ name }} must not be empty',
36		];
37
38		/**
39		* Denotes whether or not the chain should be stopped after this rule.
40		*
41		* @var bool
42		*/
43		protected $shouldBreak;
44
45		/**
46		* Indicates if the value can be empty.
47		*
48		* @var bool
49		*/
50		protected $allowEmpty;
51
52		/**
53		* Optionally contains a callable to overwrite the allow empty requirement on time of validation.
54		*
55		* @var callable
56		*/
57		protected $allowEmptyCallback;
58
59		/**
60		* Contains the input container.
61		*
62		* @var Container
63		*/
64		protected $input;
65
66		/**
67		* Construct the NotEmpty validator.
68		*
69		* @param bool $allowEmpty
70		*/
71	153	public function __construct($allowEmpty)
72		{
73	153	$this->allowEmpty = (bool) $allowEmpty;
74	153	}
75
76		/**
77		* @return bool
78		*/
79	143	public function shouldBreakChain()
80		{
81	143	return $this->shouldBreak;
82		}
83
84		/**
85		* Ensures a certain key has a value.
86		*
87		* @param mixed $value
88		* @return bool
89		*/
90	143	public function validate($value)
91		{
92	143	if ($this->isEmpty($value)) {
93	7	$this->shouldBreak = true;
94
95	7	return !$this->allowEmpty($this->input) ? $this->error(self::EMPTY_VALUE) : true;
96		}
97	137	return true;
98		}
99
100		/**
101		* Determines whether or not value $value is to be considered "empty".
102		*
103		* @param mixed $value
104		* @return bool
105		*/
106	143	protected function isEmpty($value)
107		{
108		return
109	143	(is_string($value) && strlen($value) === 0) \|\|
110	141	$value === null \|\|
111	143	(is_array($value) && count($value) === 0);
112		}
113
114		/**
115		* @inheritdoc
116		*
117		* @param string $key
118		* @param Container $input
119		* @return bool
120		*/
121	143	public function isValid($key, Container $input)
122		{
123	143	$this->input = $input;
124
125	143	return $this->validate($input->get($key));
126		}
127
128		/**
129		* Set a callable or boolean value to potentially alter the allow empty requirement at the time of validation.
130		*
131		* This may be incredibly useful for conditional validation.
132		*
133		* @param callable\|bool $allowEmpty
134		* @return $this
135		*/
136	4	public function setAllowEmpty($allowEmpty)
137		{
138	4	if (is_callable($allowEmpty)) {
139	2	return $this->setAllowEmptyCallback($allowEmpty);
140		}
141	2	return $this->overwriteAllowEmpty($allowEmpty);
142		}
143
144		/**
145		* {@inheritdoc}
146		*/
147	7	protected function getMessageParameters()
148		{
149	7	return array_merge(parent::getMessageParameters(), [
150	7	'allowEmpty' => $this->allowEmpty,
151	7	'callback' => $this->getCallbackAsString($this->allowEmptyCallback)
152	7	]);
153		}
154
155		/**
156		* Overwrite the allow empty requirement after instantiation of this rule.
157		*
158		* @param bool $allowEmpty
159		* @return $this
160		*/
161	2	protected function overwriteAllowEmpty($allowEmpty)
162		{
163	2	$this->allowEmpty = $allowEmpty;
164	2	return $this;
165		}
166
167		/**
168		* Set the callback to execute to determine whether or not the rule should allow empty.
169		*
170		* @param callable $allowEmptyCallback
171		* @return $this
172		*/
173	2	protected function setAllowEmptyCallback(callable $allowEmptyCallback)
174		{
175	2	$this->allowEmptyCallback = $allowEmptyCallback;
176	2	return $this;
177		}
178
179		/**
180		* Determines whether or not the value may be empty.
181		*
182		* @param Container $input
183		* @return bool
184		*/
185	7	protected function allowEmpty(Container $input)
186		{
187	7	if (isset($this->allowEmptyCallback)) {
188	1	$this->allowEmpty = call_user_func($this->allowEmptyCallback, $input->getArrayCopy());
189	1	}
190	7	return $this->allowEmpty;
191		}
192		}
193

particle-php / Validator

GitHub Access Token became invalid

Pull Request — master (#117)

NotEmpty::allowEmpty() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like