Validator::getDefaultMessages() - Code Metrics - Inspection of "2.x" - awurth/slim-validation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1)

by Alexis

created 2017-08-17 15:56 UTC

Validator::getDefaultMessages() A

↳ Parent: Validator

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

<?php

namespace Awurth\SlimValidation;

use InvalidArgumentException;
use Psr\Http\Message\ServerRequestInterface as Request;
use ReflectionClass;
use Respect\Validation\Exceptions\NestedValidationException;
use Respect\Validation\Rules\AbstractComposite;
use Respect\Validation\Validator as RespectValidator;

/**
 * Validator.
 *
 * @author Alexis Wurth <[email protected]>
 */
class Validator
{
    /**
     * The validated data.
     *
     * @var array
     */
    protected $data;

    /**
     * The default error messages for the given rules.
     *
     * @var array
     */
    protected $defaultMessages;

    /**
     * The list of validation errors.
     *
     * @var array
     */
    protected $errors;

    /**
     * Tells if errors should be stored in an associative array
     * where the key is the name of the validation rule.
     *
     * @var bool
     */
    protected $storeErrorsWithRules;

    /**
     * Constructor.
     *
     * @param bool $storeErrorsWithRules
     * @param array $defaultMessages
     */
    public function __construct($storeErrorsWithRules = true, array $defaultMessages = [])
    {
        $this->storeErrorsWithRules = $storeErrorsWithRules;
        $this->defaultMessages = $defaultMessages;
        $this->errors = [];
        $this->data = [];
    }

    /**
     * Tells if there is no error.
     *
     * @return bool
     */
    public function isValid()
    {
        return empty($this->errors);
    }

    /**
     * Validates request parameters with the given rules.
     *
     * @param Request $request
     * @param array $rules
     * @param array $messages
     *
     * @return $this
     */
    public function validate(Request $request, array $rules, array $messages = [])
    {
        foreach ($rules as $param => $options) {
            $value = $this->getRequestParam($request, $param);

            try {
                if ($options instanceof RespectValidator) {
                    $options->assert($value);
                } else {
                    if (!is_array($options) || !isset($options['rules']) || !($options['rules'] instanceof RespectValidator)) {
                        throw new InvalidArgumentException('Validation rules are missing');
                    }

                    $options['rules']->assert($value);
                }
            } catch (NestedValidationException $e) {
                // If the 'message' key exists, set it as only message for this param
                if (is_array($options) && isset($options['message'])) {
                    if (!is_string($options['message'])) {
                        throw new InvalidArgumentException(sprintf('Expected custom message to be of type string, %s given', gettype($options['message'])));
                    }

                    $this->errors[$param] = [$options['message']];
                } else {
                    // If the 'messages' key exists, override global messages
                    $this->setMessages($e, $param, $options, $messages);
                }
            }

            $this->data[$param] = $value;
        }

        return $this;
    }

    /**
     * Adds an error for a parameter.
     *
     * @param string $param
     * @param string $message
     *
     * @return $this
     */
    public function addError($param, $message)
    {
        $this->errors[$param][] = $message;

        return $this;
    }

    /**
     * Adds errors for a parameter.
     *
     * @deprecated since version 2.1, will be removed in 3.0.
     *
     * @param string $param
     * @param string[] $messages
     *
     * @return $this
     */
    public function addErrors($param, array $messages)
    {
        foreach ($messages as $message) {
            $this->errors[$param][] = $message;
        }

        return $this;
    }

    /**
     * Gets the validated data.
     *
     * @deprecated since version 2.1, will be removed in 3.0. Use getValues() instead.
     *
     * @return array
     */
    public function getData()
    {
        return $this->data;
    }

    /**
     * Gets all default messages.
     *
     * @return array
     */
    public function getDefaultMessages()
    {
        return $this->defaultMessages;
    }

    /**
     * Gets all errors.
     *
     * @return array
     */
    public function getErrors()
    {
        return $this->errors;
    }

    /**
     * Gets the first error of a parameter.
     *
     * @param string $param
     *
     * @return string
     */
    public function getFirstError($param)
    {
        if (isset($this->errors[$param])) {
            $first = array_slice($this->errors[$param], 0, 1);

            return array_shift($first);
        }

        return '';
    }

    /**
     * Gets errors of a parameter.
     *
     * @param string $param
     *
     * @return array
     */
    public function getParamErrors($param)
    {
        return isset($this->errors[$param]) ? $this->errors[$param] : [];
    }

    /**
     * Gets the error of a validation rule for a parameter.
     *
     * @param string $param
     * @param string $rule
     *
     * @return string
     */
    public function getParamRuleError($param, $rule)
    {
        return isset($this->errors[$param][$rule]) ? $this->errors[$param][$rule] : '';
    }

    /**
     * Tells whether errors should be stored in an associative array or an indexed array.
     *
     * @return bool
     */
    public function getStoreErrorsWithRules()
    {
        return $this->storeErrorsWithRules;
    }

    /**
     * Gets the value of a parameter in validated data.
     *
     * @param string $param
     *
     * @return string
     */
    public function getValue($param)
    {
        return isset($this->data[$param]) ? $this->data[$param] : '';
    }

    /**
     * Gets the validated data.
     *
     * @return array
     */
    public function getValues()
    {
        return $this->data;
    }

    /**
     * Sets the validator data.
     *
     * @param array $data
     *
     * @return $this
     */
    public function setData(array $data)
    {
        $this->data = $data;

        return $this;
    }

    /**
     * Sets the default error message for a validation rule.
     *
     * @param string $rule
     * @param string $message
     *
     * @return $this
     */
    public function setDefaultMessage($rule, $message)
    {
        $this->defaultMessages[$rule] = $message;

        return $this;
    }

    /**
     * Sets default error messages.
     *
     * @param array $messages
     *
     * @return $this
     */
    public function setDefaultMessages(array $messages)
    {
        $this->defaultMessages = $messages;

        return $this;
    }

    /**
     * Sets all errors.
     *
     * @param array $errors
     *
     * @return $this
     */
    public function setErrors(array $errors)
    {
        $this->errors = $errors;

        return $this;
    }

    /**
     * Sets the errors of a parameter.
     *
     * @param string $param
     * @param array $errors
     *
     * @return $this
     */
    public function setParamErrors($param, array $errors)
    {
        $this->errors[$param] = $errors;

        return $this;
    }

    /**
     * Sets errors storage mode.
     *
     * @param bool $bool
     *
     * @return $this
     */
    public function setStoreErrorsWithRules($bool)
    {
        $this->storeErrorsWithRules = (bool) $bool;

        return $this;
    }

    /**
     * Sets the value of parameters.
     *
     * @param array $data
     *
     * @return $this
     */
    public function setValues(array $data)
    {
        $this->data = array_merge($this->data, $data);

        return $this;
    }

    /**
     * Fetch request parameter value from body or query string (in that order).
     *
     * @param  Request $request
     * @param  string  $key The parameter key.
     * @param  string  $default The default value.
     *
     * @return mixed The parameter value.
     */
    protected function getRequestParam(Request $request, $key, $default = null)
    {
        $postParams = $request->getParsedBody();
        $getParams = $request->getQueryParams();

        $result = $default;
        if (is_array($postParams) && isset($postParams[$key])) {
            $result = $postParams[$key];
        } elseif (is_object($postParams) && property_exists($postParams, $key)) {
            $result = $postParams->$key;
        } elseif (isset($getParams[$key])) {
            $result = $getParams[$key];
        }

        return $result;
    }

    /**
     * Sets error messages after validation.
     *
     * @param NestedValidationException $e
     * @param string $param
     * @param AbstractComposite|array $options
     * @param array $messages
     */
    protected function setMessages(NestedValidationException $e, $param, $options, array $messages)
    {
        $paramRules = $options instanceof RespectValidator ? $options->getRules() : $options['rules']->getRules();

        // Get the names of all rules used for this param
        $rulesNames = [];
        foreach ($paramRules as $rule) {
            $rulesNames[] = lcfirst((new ReflectionClass($rule))->getShortName());
        }

        $params = [
            $e->findMessages($rulesNames)
        ];

        // If default messages are defined
        if (!empty($this->defaultMessages)) {
            $params[] = $e->findMessages($this->defaultMessages);
        }

        // If global messages are defined
        if (!empty($messages)) {
            $params[] = $e->findMessages($messages);
        }

        // If individual messages are defined
        if (is_array($options) && isset($options['messages'])) {
            if (!is_array($options['messages'])) {
                throw new InvalidArgumentException(sprintf('Expected custom individual messages to be of type array, %s given', gettype($options['messages'])));
            }

            $params[] = $e->findMessages($options['messages']);
        }

        $errors = array_filter(call_user_func_array('array_merge', $params));

        $this->errors[$param] = $this->storeErrorsWithRules ? $errors : array_values($errors);
    }
}


1			<?php
2
3			namespace Awurth\SlimValidation;
4
5			use InvalidArgumentException;
6			use Psr\Http\Message\ServerRequestInterface as Request;
7			use ReflectionClass;
8			use Respect\Validation\Exceptions\NestedValidationException;
9			use Respect\Validation\Rules\AbstractComposite;
10			use Respect\Validation\Validator as RespectValidator;
11
12			/**
13			* Validator.
14			*
15			* @author Alexis Wurth <[email protected]>
16			*/
17			class Validator
18			{
19			/**
20			* The validated data.
21			*
22			* @var array
23			*/
24			protected $data;
25
26			/**
27			* The default error messages for the given rules.
28			*
29			* @var array
30			*/
31			protected $defaultMessages;
32
33			/**
34			* The list of validation errors.
35			*
36			* @var array
37			*/
38			protected $errors;
39
40			/**
41			* Tells if errors should be stored in an associative array
42			* where the key is the name of the validation rule.
43			*
44			* @var bool
45			*/
46			protected $storeErrorsWithRules;
47
48			/**
49			* Constructor.
50			*
51			* @param bool $storeErrorsWithRules
52			* @param array $defaultMessages
53			*/
54			public function __construct($storeErrorsWithRules = true, array $defaultMessages = [])
55			{
56			$this->storeErrorsWithRules = $storeErrorsWithRules;
57			$this->defaultMessages = $defaultMessages;
58			$this->errors = [];
59			$this->data = [];
60			}
61
62			/**
63			* Tells if there is no error.
64			*
65			* @return bool
66			*/
67			public function isValid()
68			{
69			return empty($this->errors);
70			}
71
72			/**
73			* Validates request parameters with the given rules.
74			*
75			* @param Request $request
76			* @param array $rules
77			* @param array $messages
78			*
79			* @return $this
80			*/
81			public function validate(Request $request, array $rules, array $messages = [])
82			{
83			foreach ($rules as $param => $options) {
84			$value = $this->getRequestParam($request, $param);
85
86			try {
87			if ($options instanceof RespectValidator) {
88			$options->assert($value);
89			} else {
90			if (!is_array($options) \|\| !isset($options['rules']) \|\| !($options['rules'] instanceof RespectValidator)) {
91			throw new InvalidArgumentException('Validation rules are missing');
92			}
93
94			$options['rules']->assert($value);
95			}
96			} catch (NestedValidationException $e) {
97			// If the 'message' key exists, set it as only message for this param
98			if (is_array($options) && isset($options['message'])) {
99			if (!is_string($options['message'])) {
100			throw new InvalidArgumentException(sprintf('Expected custom message to be of type string, %s given', gettype($options['message'])));
101			}
102
103			$this->errors[$param] = [$options['message']];
104			} else {
105			// If the 'messages' key exists, override global messages
106			$this->setMessages($e, $param, $options, $messages);
107			}
108			}
109
110			$this->data[$param] = $value;
111			}
112
113			return $this;
114			}
115
116			/**
117			* Adds an error for a parameter.
118			*
119			* @param string $param
120			* @param string $message
121			*
122			* @return $this
123			*/
124			public function addError($param, $message)
125			{
126			$this->errors[$param][] = $message;
127
128			return $this;
129			}
130
131			/**
132			* Adds errors for a parameter.
133			*
134			* @deprecated since version 2.1, will be removed in 3.0.
135			*
136			* @param string $param
137			* @param string[] $messages
138			*
139			* @return $this
140			*/
141			public function addErrors($param, array $messages)
142			{
143			foreach ($messages as $message) {
144			$this->errors[$param][] = $message;
145			}
146
147			return $this;
148			}
149
150			/**
151			* Gets the validated data.
152			*
153			* @deprecated since version 2.1, will be removed in 3.0. Use getValues() instead.
154			*
155			* @return array
156			*/
157			public function getData()
158			{
159			return $this->data;
160			}
161
162			/**
163			* Gets all default messages.
164			*
165			* @return array
166			*/
167			public function getDefaultMessages()
168			{
169			return $this->defaultMessages;
170			}
171
172			/**
173			* Gets all errors.
174			*
175			* @return array
176			*/
177			public function getErrors()
178			{
179			return $this->errors;
180			}
181
182			/**
183			* Gets the first error of a parameter.
184			*
185			* @param string $param
186			*
187			* @return string
188			*/
189			public function getFirstError($param)
190			{
191			if (isset($this->errors[$param])) {
192			$first = array_slice($this->errors[$param], 0, 1);
193
194			return array_shift($first);
195			}
196
197			return '';
198			}
199
200			/**
201			* Gets errors of a parameter.
202			*
203			* @param string $param
204			*
205			* @return array
206			*/
207			public function getParamErrors($param)
208			{
209			return isset($this->errors[$param]) ? $this->errors[$param] : [];
210			}
211
212			/**
213			* Gets the error of a validation rule for a parameter.
214			*
215			* @param string $param
216			* @param string $rule
217			*
218			* @return string
219			*/
220			public function getParamRuleError($param, $rule)
221			{
222			return isset($this->errors[$param][$rule]) ? $this->errors[$param][$rule] : '';
223			}
224
225			/**
226			* Tells whether errors should be stored in an associative array or an indexed array.
227			*
228			* @return bool
229			*/
230			public function getStoreErrorsWithRules()
231			{
232			return $this->storeErrorsWithRules;
233			}
234
235			/**
236			* Gets the value of a parameter in validated data.
237			*
238			* @param string $param
239			*
240			* @return string
241			*/
242			public function getValue($param)
243			{
244			return isset($this->data[$param]) ? $this->data[$param] : '';
245			}
246
247			/**
248			* Gets the validated data.
249			*
250			* @return array
251			*/
252			public function getValues()
253			{
254			return $this->data;
255			}
256
257			/**
258			* Sets the validator data.
259			*
260			* @param array $data
261			*
262			* @return $this
263			*/
264			public function setData(array $data)
265			{
266			$this->data = $data;
267
268			return $this;
269			}
270
271			/**
272			* Sets the default error message for a validation rule.
273			*
274			* @param string $rule
275			* @param string $message
276			*
277			* @return $this
278			*/
279			public function setDefaultMessage($rule, $message)
280			{
281			$this->defaultMessages[$rule] = $message;
282
283			return $this;
284			}
285
286			/**
287			* Sets default error messages.
288			*
289			* @param array $messages
290			*
291			* @return $this
292			*/
293			public function setDefaultMessages(array $messages)
294			{
295			$this->defaultMessages = $messages;
296
297			return $this;
298			}
299
300			/**
301			* Sets all errors.
302			*
303			* @param array $errors
304			*
305			* @return $this
306			*/
307			public function setErrors(array $errors)
308			{
309			$this->errors = $errors;
310
311			return $this;
312			}
313
314			/**
315			* Sets the errors of a parameter.
316			*
317			* @param string $param
318			* @param array $errors
319			*
320			* @return $this
321			*/
322			public function setParamErrors($param, array $errors)
323			{
324			$this->errors[$param] = $errors;
325
326			return $this;
327			}
328
329			/**
330			* Sets errors storage mode.
331			*
332			* @param bool $bool
333			*
334			* @return $this
335			*/
336			public function setStoreErrorsWithRules($bool)
337			{
338			$this->storeErrorsWithRules = (bool) $bool;
339
340			return $this;
341			}
342
343			/**
344			* Sets the value of parameters.
345			*
346			* @param array $data
347			*
348			* @return $this
349			*/
350			public function setValues(array $data)
351			{
352			$this->data = array_merge($this->data, $data);
353
354			return $this;
355			}
356
357			/**
358			* Fetch request parameter value from body or query string (in that order).
359			*
360			* @param Request $request
361			* @param string $key The parameter key.
362			* @param string $default The default value.
363			*
364			* @return mixed The parameter value.
365			*/
366			protected function getRequestParam(Request $request, $key, $default = null)
367			{
368			$postParams = $request->getParsedBody();
369			$getParams = $request->getQueryParams();
370
371			$result = $default;
372			if (is_array($postParams) && isset($postParams[$key])) {
373			$result = $postParams[$key];
374			} elseif (is_object($postParams) && property_exists($postParams, $key)) {
375			$result = $postParams->$key;
376			} elseif (isset($getParams[$key])) {
377			$result = $getParams[$key];
378			}
379
380			return $result;
381			}
382
383			/**
384			* Sets error messages after validation.
385			*
386			* @param NestedValidationException $e
387			* @param string $param
388			* @param AbstractComposite\|array $options
389			* @param array $messages
390			*/
391			protected function setMessages(NestedValidationException $e, $param, $options, array $messages)
392			{
393			$paramRules = $options instanceof RespectValidator ? $options->getRules() : $options['rules']->getRules();
394
395			// Get the names of all rules used for this param
396			$rulesNames = [];
397			foreach ($paramRules as $rule) {
398			$rulesNames[] = lcfirst((new ReflectionClass($rule))->getShortName());
399			}
400
401			$params = [
402			$e->findMessages($rulesNames)
403			];
404
405			// If default messages are defined
406			if (!empty($this->defaultMessages)) {
407			$params[] = $e->findMessages($this->defaultMessages);
408			}
409
410			// If global messages are defined
411			if (!empty($messages)) {
412			$params[] = $e->findMessages($messages);
413			}
414
415			// If individual messages are defined
416			if (is_array($options) && isset($options['messages'])) {
417			if (!is_array($options['messages'])) {
418			throw new InvalidArgumentException(sprintf('Expected custom individual messages to be of type array, %s given', gettype($options['messages'])));
419			}
420
421			$params[] = $e->findMessages($options['messages']);
422			}
423
424			$errors = array_filter(call_user_func_array('array_merge', $params));
425
426			$this->errors[$param] = $this->storeErrorsWithRules ? $errors : array_values($errors);
427			}
428			}
429

awurth / slim-validation

Pull Request — master (#1)

Validator::getDefaultMessages() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like