NotEmpty::isEmpty() - 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-18 22:35 UTC

NotEmpty::isEmpty() B

↳ Parent: NotEmpty

Complexity

Conditions	6
Paths	4

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	6

Importance

Changes	4
Bugs	1	Features	0

Metric	Value
c	4
b	1
f	0
dl	0
loc	12
ccs	8
cts	8
cp	1
rs	8.8571
cc	6
eloc	8
nc	4
nop	1
crap	6

<?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)
    {
        if (is_string($value) && strlen($value) === 0) {
            return true;
        } elseif ($value === null) {
            return true;
        } elseif (is_array($value) && count($value) === 0) {
            return true;
        }

        return false;
    }

    /**
     * @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	143	if (is_string($value) && strlen($value) === 0) {
109	3	return true;
110	141	} elseif ($value === null) {
111	4	return true;
112	138	} elseif (is_array($value) && count($value) === 0) {
113	1	return true;
114		}
115
116	137	return false;
117		}
118
119		/**
120		* @inheritdoc
121		*
122		* @param string $key
123		* @param Container $input
124		* @return bool
125		*/
126	143	public function isValid($key, Container $input)
127		{
128	143	$this->input = $input;
129
130	143	return $this->validate($input->get($key));
131		}
132
133		/**
134		* Set a callable or boolean value to potentially alter the allow empty requirement at the time of validation.
135		*
136		* This may be incredibly useful for conditional validation.
137		*
138		* @param callable\|bool $allowEmpty
139		* @return $this
140		*/
141	4	public function setAllowEmpty($allowEmpty)
142		{
143	4	if (is_callable($allowEmpty)) {
144	2	return $this->setAllowEmptyCallback($allowEmpty);
145		}
146	2	return $this->overwriteAllowEmpty($allowEmpty);
147		}
148
149		/**
150		* {@inheritdoc}
151		*/
152	7	protected function getMessageParameters()
153		{
154	7	return array_merge(parent::getMessageParameters(), [
155	7	'allowEmpty' => $this->allowEmpty,
156	7	'callback' => $this->getCallbackAsString($this->allowEmptyCallback)
157	7	]);
158		}
159
160		/**
161		* Overwrite the allow empty requirement after instantiation of this rule.
162		*
163		* @param bool $allowEmpty
164		* @return $this
165		*/
166	2	protected function overwriteAllowEmpty($allowEmpty)
167		{
168	2	$this->allowEmpty = $allowEmpty;
169	2	return $this;
170		}
171
172		/**
173		* Set the callback to execute to determine whether or not the rule should allow empty.
174		*
175		* @param callable $allowEmptyCallback
176		* @return $this
177		*/
178	2	protected function setAllowEmptyCallback(callable $allowEmptyCallback)
179		{
180	2	$this->allowEmptyCallback = $allowEmptyCallback;
181	2	return $this;
182		}
183
184		/**
185		* Determines whether or not the value may be empty.
186		*
187		* @param Container $input
188		* @return bool
189		*/
190	7	protected function allowEmpty(Container $input)
191		{
192	7	if (isset($this->allowEmptyCallback)) {
193	1	$this->allowEmpty = call_user_func($this->allowEmptyCallback, $input->getArrayCopy());
194	1	}
195	7	return $this->allowEmpty;
196		}
197		}
198

particle-php / Validator

GitHub Access Token became invalid

Pull Request — master (#117)

NotEmpty::isEmpty() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like