Awurth\SlimValidation\Validator

Complexity

Total Complexity

82

Size/Duplication

Total Lines	570
Duplicated Lines	15.44 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	7	1
A	isValid()	0	4	1
B	array()	14	14	5
B	object()	14	14	5
B	request()	14	14	5
B	validate()	0	16	6
C	value()	5	42	14
A	count()	0	4	1
A	addError()	10	10	2
A	getDefaultMessages()	0	4	1
A	getErrors()	0	4	1
A	getFirstError()	0	16	4
A	getParamErrors()	0	8	2
A	getParamRuleError()	8	8	2
A	getValue()	8	8	2
A	getValues()	0	4	1
A	getErrorStorageMode()	0	4	1
A	setDefaultMessage()	0	6	1
A	setDefaultMessages()	0	6	1
A	setErrors()	0	6	1
A	setErrorStorageMode()	0	6	1
A	setParamErrors()	10	10	2
A	setValue()	5	10	2
A	setValues()	0	6	1
A	getPropertyValue()	0	11	2
B	getRequestParam()	0	16	6
D	setMessages()	0	41	11

<?php

namespace Awurth\SlimValidation;

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

/**
 * Validator.
 *
 * @author Alexis Wurth <alexis.wurth57@gmail.com>
 */
class Validator
{
    const MODE_ASSOCIATIVE = 1;
    const MODE_INDEXED = 2;

    /**
     * The validated data.
     *
     * @var array
     */
    protected $values;

    /**
     * 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
     * or in an indexed array.
     *
     * @var int
     */
    protected $errorStorageMode;

    /**
     * Constructor.
     *
     * @param int $errorStorageMode
     * @param array $defaultMessages
     */
    public function __construct(int $errorStorageMode = self::MODE_ASSOCIATIVE, array $defaultMessages = [])
    {
        $this->errorStorageMode = $errorStorageMode;
        $this->defaultMessages = $defaultMessages;
        $this->errors = [];
        $this->values = [];
    }

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

    /**
     * Validates an array with the given rules.
     *
     * @param array      $array
     * @param array      $rules
     * @param array      $messages
     * @param string|int $group
     *
     * @return self
     */
    public function array(array $array, array $rules, array $messages = [], $group = null)

This method seems to be duplicated in your project.

    {
        if (null !== $group && (!is_string($group) || !is_int($group))) {
            throw new InvalidArgumentException('The group must be either a string or an integer');
        }

        foreach ($rules as $key => $options) {
            $value = $array[$key] ?? null;

            $this->value($value, $key, $options, $messages, $group);
        }

        return $this;
    }

    /**
     * Validates an objects properties with the given rules.
     *
     * @param object     $object
     * @param array      $rules
     * @param array      $messages
     * @param string|int $group
     *
     * @return self
     */
    public function object(object $object, array $rules, array $messages = [], $group = null)

This method seems to be duplicated in your project.

    {
        if (null !== $group && (!is_string($group) || !is_int($group))) {
            throw new InvalidArgumentException('The group must be either a string or an integer');
        }

        foreach ($rules as $property => $options) {
            $value = $this->getPropertyValue($object, $property);

            $this->value($value, $property, $options, $messages, $group);
        }

        return $this;
    }

    /**
     * Validates request parameters with the given rules.
     *
     * @param Request    $request
     * @param array      $rules
     * @param array      $messages
     * @param string|int $group
     *
     * @return self
     */
    public function request(Request $request, array $rules, array $messages = [], $group = null)

This method seems to be duplicated in your project.

    {
        if (null !== $group && (!is_string($group) || !is_int($group))) {
            throw new InvalidArgumentException('The group must be either a string or an integer');
        }

        foreach ($rules as $param => $options) {
            $value = $this->getRequestParam($request, $param);

            $this->value($value, $param, $options, $messages, $group);
        }

        return $this;
    }

    /**
     * Validates request parameters, an array or an objects properties.
     *
     * @param Request|object|array $input
     * @param array                $rules
     * @param array                $messages
     * @param string|int           $group
     *
     * @return self
     */
    public function validate($input, array $rules, array $messages = [], $group = null)
    {
        if (!is_object($input) && !is_array($input)) {
            throw new InvalidArgumentException('The input must be either an object or an array');
        }

        if ($input instanceof Request) {
            return $this->request($input, $rules, $messages, $group);
        } elseif (is_array($input)) {
            return $this->array($input, $rules, $messages, $group);
        } elseif (is_object($input)) {
            return $this->object($input, $rules, $messages, $group);
        }

        return $this;
    }

    /**
     * Validates a single value with the given rules.
     *
     * @param mixed                  $value
     * @param string                 $key
     * @param RespectValidator|array $rules
     * @param array                  $messages
     * @param string|int             $group
     *
     * @return self
     */
    public function value($value, $key, $rules, array $messages = [], $group = null)
    {
        if (null !== $group && (!is_string($group) || !is_int($group))) {
            throw new InvalidArgumentException('The group must be either a string or an integer');
        }

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

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

                if (null !== $group) {
                    $this->errors[$group][$key] = [$rules['message']];
                } else {
                    $this->errors[$key] = [$rules['message']];
                }
            } else {
                // If the 'messages' key exists, override global messages
                $this->setMessages($e, $key, $rules, $messages, $group);
            }
        }

        if (null !== $group) {

This code seems to be duplicated across your project.

            $this->values[$group][$key] = $value;
        } else {
            $this->values[$key] = $value;
        }

        return $this;
    }

    /**
     * Gets the error count.
     *
     * @return int
     */
    public function count()
    {
        return count($this->errors);
    }

    /**
     * Adds an error for a parameter.
     *
     * @param string $param
     * @param string $message
     * @param string $group
     *
     * @return self
     */
    public function addError($param, $message, $group = null)

This method seems to be duplicated in your project.

    {
        if (null !== $group) {
            $this->errors[$group][$param][] = $message;
        } else {
            $this->errors[$param][] = $message;
        }

        return $this;
    }

    /**
     * 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
     * @param string $group
     *
     * @return string
     */
    public function getFirstError($param, $group = null)
    {
        if (null !== $group) {
            if (isset($this->errors[$group][$param])) {
                $first = array_slice($this->errors[$group][$param], 0, 1);

                return array_shift($first);
            }
        } elseif (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
     * @param string $group
     *
     * @return array
     */
    public function getParamErrors($param, $group = null)
    {
        if (null !== $group) {
            return $this->errors[$group][$param] ?? [];
        }

        return $this->errors[$param] ?? [];
    }

    /**
     * Gets the error of a validation rule for a parameter.
     *
     * @param string $param
     * @param string $rule
     * @param string $group
     *
     * @return string
     */
    public function getParamRuleError($param, $rule, $group = null)

This method seems to be duplicated in your project.

    {
        if (null !== $group) {
            return $this->errors[$group][$param][$rule] ?? '';
        }

        return $this->errors[$param][$rule] ?? '';
    }

    /**
     * Gets the value of a request parameter in validated data.
     *
     * @param string $param
     * @param string $group
     *
     * @return string
     */
    public function getValue($param, $group = null)

This method seems to be duplicated in your project.

    {
        if (null !== $group) {
            return $this->values[$group][$param] ?? '';
        }

        return $this->values[$param] ?? '';
    }

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

    /**
     * Gets the error storage mode.
     *
     * @return int
     */
    public function getErrorStorageMode()
    {
        return $this->errorStorageMode;
    }

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

        return $this;
    }

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

        return $this;
    }

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

        return $this;
    }

    /**
     * Sets the error storage mode.
     *
     * @param int $errorStorageMode
     *
     * @return self
     */
    public function setErrorStorageMode(int $errorStorageMode)
    {
        $this->errorStorageMode = $errorStorageMode;

        return $this;
    }

    /**
     * Sets the errors of a parameter.
     *
     * @param string $param
     * @param array  $errors
     * @param string $group
     *
     * @return self
     */
    public function setParamErrors($param, array $errors, $group = null)

This method seems to be duplicated in your project.

    {
        if (null !== $group) {
            $this->errors[$group][$param] = $errors;
        } else {
            $this->errors[$param] = $errors;
        }

        return $this;
    }

    /**
     * Sets the value of a request parameter.
     *
     * @param string $param
     * @param mixed  $value
     * @param string $group
     *
     * @return self
     */
    public function setValue($param, $value, $group = null)
    {
        if (null !== $group) {

This code seems to be duplicated across your project.

            $this->values[$group][$param] = $value;
        } else {
            $this->values[$param] = $value;
        }

        return $this;
    }

    /**
     * Sets the values of request parameters.
     *
     * @param array $values
     *
     * @return self
     */
    public function setValues(array $values)
    {
        $this->values = $values;

        return $this;
    }

    /**
     * Gets the value of a property of an object.
     *
     * @param object $object
     * @param string $propertyName
     * @param mixed  $default
     *
     * @return mixed
     */
    protected function getPropertyValue(object $object, string $propertyName, $default = null)
    {
        if (!property_exists($object, $propertyName)) {
            return $default;
        }

        $reflectionProperty = new ReflectionProperty($object, $propertyName);
        $reflectionProperty->setAccessible(true);

        return $reflectionProperty->getValue($object);
    }

    /**
     * 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
     * @param string|int                $group
     */
    protected function setMessages(NestedValidationException $e, $param, $options, array $messages = [], $group = null)
    {
        $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));

        if (null !== $group) {
            $this->errors[$group][$param] = $this->errorStorageMode === self::MODE_ASSOCIATIVE ? $errors : array_values($errors);
        } else {
            $this->errors[$param] = $this->errorStorageMode === self::MODE_ASSOCIATIVE ? $errors : array_values($errors);
        }
    }
}