Validator::getError() - Code Metrics - Inspection of "Fixed REST controller and Response" - bluzphp/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#357)

by Anton

created 2016-02-01 11:34 UTC

Validator::getError() A

↳ Parent: Validator

Complexity

Conditions	3
Paths	3

Size

Total Lines	16
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	3.0175

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	16
ccs	7
cts	8
cp	0.875
rs	9.4285
cc	3
eloc	8
nc	3
nop	0
crap	3.0175

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

/**
 * @namespace
 */
namespace Bluz\Validator;

use Bluz\Validator\Rule\AbstractRule;
use Bluz\Validator\Exception\ComponentException;
use Bluz\Validator\Exception\ValidatorException;
use Bluz\Validator\Rule\Required;

/**
 * Validator
 *
 * @package  Bluz\Validator
 * @author   Anton Shevchuk
 * @link     https://github.com/Respect/Validation
 *
 * @method static Validator alpha($additionalCharacters = '')
 * @method static Validator alphaNumeric($additionalCharacters = '')
 * @method static Validator arrayInput($callback)
 * @method static Validator between($min, $max, $inclusive = false)
 * @method static Validator callback($callback)
 * @method static Validator condition($condition)
 * @method static Validator contains($containsValue, $identical = false)
 * @method static Validator countryCode()
 * @method static Validator creditCard()
 * @method static Validator date($format)
 * @method static Validator domain($checkDns = false)
 * @method static Validator email($checkDns = false)
 * @method static Validator equals($compareTo, $identical = false)
 * @method static Validator float()
 * @method static Validator in($haystack, $identical = false)
 * @method static Validator integer()
 * @method static Validator ip($options = null)
 * @method static Validator json()
 * @method static Validator latin($additionalCharacters = '')
 * @method static Validator latinNumeric($additionalCharacters = '')
 * @method static Validator length($min = null, $max = null, $inclusive = true)
 * @method static Validator max($maxValue, $inclusive = false)
 * @method static Validator min($minValue, $inclusive = false)
 * @method static Validator notEmpty()
 * @method static Validator noWhitespace()
 * @method static Validator numeric()
 * @method static Validator required()
 * @method static Validator regexp($expression)
 * @method static Validator slug()
 * @method static Validator string()
 */
class Validator
{
    /**
     * @var AbstractRule[] list of validation rules
     */
    protected $rules = array();

    /**
     * @var AbstractRule[] list of invalid rules
     */
    protected $invalid = array();

    /**
     * @var string field name
     */
    protected $name;

    /**
     * @var string input data
     */
    protected $input;

    /**
     * @var string error text
     */
    protected $error;

    /**
     * Create new instance if Validator
     *
     * @return Validator
     */
    public static function create()
    {
        return new static;
    }

    /**
     * Magic static call for create instance of Validator
     *
     * @param string $ruleName
     * @param array  $arguments
     * @return Validator
     */
    public static function __callStatic($ruleName, $arguments)
    {
        $validator = self::create();

        return $validator->__call($ruleName, $arguments);
    }

    /**
     * Magic call for create new rule
     *
     * @param  string $ruleName
     * @param  array  $arguments
     * @return Validator
     * @throws Exception\ComponentException
     */
    public function __call($ruleName, $arguments)
    {
        if (in_array($ruleName, ['array', 'float', 'string'])) {
            $ruleName .= 'Input';
        }

        $ruleClass = '\\Bluz\\Validator\\Rule\\' . ucfirst($ruleName);

        if (!class_exists($ruleClass)) {
            throw new ComponentException("Class for validator `$ruleName` not found");
        }

        if (sizeof($arguments)) {
            $reflection = new \ReflectionClass($ruleClass);
            $rule = $reflection->newInstanceArgs($arguments);
        } else {
            $rule = new $ruleClass();
        }

        $this->rules[] = $rule;

        return $this;
    }

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

    /**
     * Set field Title
     *
     * @param string $name
     * @return Validator
     */
    public function setName($name)
    {
        $this->name = $name;
        return $this;
    }

    /**
     * Get field Title
     *
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * Get input data
     *
     * @return string
     */
    public function getInput()
    {
        return $this->input;
    }

    /**
     * Callable
     *
     * @param mixed $input
     * @return bool
     */
    public function __invoke($input)
    {
        return $this->validate($input);
    }

    /**
     * Validate chain of rules
     *
     * @param mixed $input
     * @param bool  $all
     * @return bool
     */
    public function validate($input, $all = false)
    {
        $this->input = $input;
        $this->invalid = array(); // clean
        foreach ($this->rules as $rule) {
            if (!$rule->validate($this->input)) {
                $this->invalid[] = $rule;
                if (!$all) {
                    break;
                }
            }
        }
        return sizeof($this->invalid) ? false : true;
    }

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

    /**
     * Set error template for complex rule
     *
     * @param  string $message
     * @return Validator
     */
    public function setError($message)
    {
        $this->error = $message;
        return $this;
    }

    /**
     * Get error message
     *
     * @return false|string
     */
    public function getError()
    {
        // nothing for valid
        if (!sizeof($this->invalid)) {
            return false;
        }

        // one custom message for all rules in chain
        // or predefined message from last rule in chain
        if ($this->error) {
            $output = $this->error;
        } else {
            $output = end($this->invalid);
        }
        return $this->prepareError($output);
    }

    /**
     * Get all errors
     *
     * @return string[]
     */
    public function getErrors()
    {
        $output = array();
        foreach ($this->invalid as $rule) {
            $output[] = $this->prepareError($rule);
        }
        return $output;
    }

    /**
     * Prepare error message for output
     *
     * @param  string $message
     * @return string
     */
    protected function prepareError($message)
    {
        $input = $this->getInput();
        if (is_array($input)) {
            $input = join(', ', $input);
        }

        $message = str_replace('{{name}}', $this->getName(), $message);
        $message = str_replace('{{input}}', esc($input), $message);

        return $message;
    }

    /**
     * Cast to string
     *
     * @return string
     */
    public function __toString()
    {
        // custom message for all chain of rules
        if ($this->error) {
            $output = $this->error;
        } else {
            $output = join("\n", $this->rules);
        }
        return $this->prepareError($output);
    }
}


1		<?php
2		/**
3		* Bluz Framework Component
4		*
5		* @copyright Bluz PHP Team
6		* @link https://github.com/bluzphp/framework
7		*/
8
9		/**
10		* @namespace
11		*/
12		namespace Bluz\Validator;
13
14		use Bluz\Validator\Rule\AbstractRule;
15		use Bluz\Validator\Exception\ComponentException;
16		use Bluz\Validator\Exception\ValidatorException;
17		use Bluz\Validator\Rule\Required;
18
19		/**
20		* Validator
21		*
22		* @package Bluz\Validator
23		* @author Anton Shevchuk
24		* @link https://github.com/Respect/Validation
25		*
26		* @method static Validator alpha($additionalCharacters = '')
27		* @method static Validator alphaNumeric($additionalCharacters = '')
28		* @method static Validator arrayInput($callback)
29		* @method static Validator between($min, $max, $inclusive = false)
30		* @method static Validator callback($callback)
31		* @method static Validator condition($condition)
32		* @method static Validator contains($containsValue, $identical = false)
33		* @method static Validator countryCode()
34		* @method static Validator creditCard()
35		* @method static Validator date($format)
36		* @method static Validator domain($checkDns = false)
37		* @method static Validator email($checkDns = false)
38		* @method static Validator equals($compareTo, $identical = false)
39		* @method static Validator float()
40		* @method static Validator in($haystack, $identical = false)
41		* @method static Validator integer()
42		* @method static Validator ip($options = null)
43		* @method static Validator json()
44		* @method static Validator latin($additionalCharacters = '')
45		* @method static Validator latinNumeric($additionalCharacters = '')
46		* @method static Validator length($min = null, $max = null, $inclusive = true)
47		* @method static Validator max($maxValue, $inclusive = false)
48		* @method static Validator min($minValue, $inclusive = false)
49		* @method static Validator notEmpty()
50		* @method static Validator noWhitespace()
51		* @method static Validator numeric()
52		* @method static Validator required()
53		* @method static Validator regexp($expression)
54		* @method static Validator slug()
55		* @method static Validator string()
56		*/
57		class Validator
58		{
59		/**
60		* @var AbstractRule[] list of validation rules
61		*/
62		protected $rules = array();
63
64		/**
65		* @var AbstractRule[] list of invalid rules
66		*/
67		protected $invalid = array();
68
69		/**
70		* @var string field name
71		*/
72		protected $name;
73
74		/**
75		* @var string input data
76		*/
77		protected $input;
78
79		/**
80		* @var string error text
81		*/
82		protected $error;
83
84		/**
85		* Create new instance if Validator
86		*
87		* @return Validator
88		*/
89	23	public static function create()
90		{
91	23	return new static;
92		}
93
94		/**
95		* Magic static call for create instance of Validator
96		*
97		* @param string $ruleName
98		* @param array $arguments
99		* @return Validator
100		*/
101	19	public static function __callStatic($ruleName, $arguments)
102		{
103	19	$validator = self::create();
104
105	19	return $validator->__call($ruleName, $arguments);
106		}
107
108		/**
109		* Magic call for create new rule
110		*
111		* @param string $ruleName
112		* @param array $arguments
113		* @return Validator
114		* @throws Exception\ComponentException
115		*/
116	22	public function __call($ruleName, $arguments)
117		{
118	22	if (in_array($ruleName, ['array', 'float', 'string'])) {
119	1	$ruleName .= 'Input';
120	1	}
121
122	22	$ruleClass = '\\Bluz\\Validator\\Rule\\' . ucfirst($ruleName);
123
124	22	if (!class_exists($ruleClass)) {
125	1	throw new ComponentException("Class for validator `$ruleName` not found");
126		}
127
128	21	if (sizeof($arguments)) {
129	10	$reflection = new \ReflectionClass($ruleClass);
130	10	$rule = $reflection->newInstanceArgs($arguments);
131	10	} else {
132	16	$rule = new $ruleClass();
133		}
134
135	21	$this->rules[] = $rule;
136
137	21	return $this;
138		}
139
140		/**
141		* Get required flag
142		*
143		* @return bool
144		*/
145	4	public function isRequired()
146		{
147	4	foreach ($this->rules as $rule) {
148	4	if ($rule instanceof Required) {
149	3	return true;
150		}
151	2	}
152	2	return false;
153		}
154
155		/**
156		* Set field Title
157		*
158		* @param string $name
159		* @return Validator
160		*/
161	18	public function setName($name)
162		{
163	18	$this->name = $name;
164	18	return $this;
165		}
166
167		/**
168		* Get field Title
169		*
170		* @return string
171		*/
172	19	public function getName()
173		{
174	19	return $this->name;
175		}
176
177		/**
178		* Get input data
179		*
180		* @return string
181		*/
182	13	public function getInput()
183		{
184	13	return $this->input;
185		}
186
187		/**
188		* Callable
189		*
190		* @param mixed $input
191		* @return bool
192		*/
193	1	public function __invoke($input)
194		{
195	1	return $this->validate($input);
196		}
197
198		/**
199		* Validate chain of rules
200		*
201		* @param mixed $input
202		* @param bool $all
203		* @return bool
204		*/
205	20	public function validate($input, $all = false)
206		{
207	20	$this->input = $input;
208	20	$this->invalid = array(); // clean
209	20	foreach ($this->rules as $rule) {
210	20	if (!$rule->validate($this->input)) {
211	13	$this->invalid[] = $rule;
212	13	if (!$all) {
213	13	break;
214		}
215		}
216	20	}
217	20	return sizeof($this->invalid) ? false : true;
218		}
219
220		/**
221		* Assert
222		*
223		* @param mixed $input
224		* @return bool
225		* @throws ValidatorException
226		*/
227	4	public function assert($input)
228		{
229	4	if (!$this->validate($input)) {
230	3	throw new ValidatorException($this->getError()?:'');
231		}
232	1	return true;
233		}
234
235		/**
236		* Set error template for complex rule
237		*
238		* @param string $message
239		* @return Validator
240		*/
241	5	public function setError($message)
242		{
243	5	$this->error = $message;
244	5	return $this;
245		}
246
247		/**
248		* Get error message
249		*
250		* @return false\|string
251		*/
252	12	public function getError()
253		{
254		// nothing for valid
255	12	if (!sizeof($this->invalid)) {
256		return false;
257		}
258
259		// one custom message for all rules in chain
260		// or predefined message from last rule in chain
261	12	if ($this->error) {
262	4	$output = $this->error;
263	4	} else {
264	8	$output = end($this->invalid);
265		}
266	12	return $this->prepareError($output);
267		}
268
269		/**
270		* Get all errors
271		*
272		* @return string[]
273		*/
274	1	public function getErrors()
275		{
276	1	$output = array();
277	1	foreach ($this->invalid as $rule) {
278	1	$output[] = $this->prepareError($rule);
279	1	}
280	1	return $output;
281		}
282
283		/**
284		* Prepare error message for output
285		*
286		* @param string $message
287		* @return string
288		*/
289	13	protected function prepareError($message)
290		{
291	13	$input = $this->getInput();
292	13	if (is_array($input)) {
293	1	$input = join(', ', $input);
294	1	}
295
296	13	$message = str_replace('{{name}}', $this->getName(), $message);
297	13	$message = str_replace('{{input}}', esc($input), $message);
298
299	13	return $message;
300		}
301
302		/**
303		* Cast to string
304		*
305		* @return string
306		*/
307	1	public function __toString()
308		{
309		// custom message for all chain of rules
310	1	if ($this->error) {
311	1	$output = $this->error;
312	1	} else {
313	1	$output = join("\n", $this->rules);
314		}
315	1	return $this->prepareError($output);
316		}
317		}
318

bluzphp / framework

Pull Request — master (#357)

Validator::getError() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like