DavidePastore\Slim\Validation\Validation

Complexity

Total Complexity

26

Size/Duplication

Total Lines	262
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getNestedParam()	0	16	4
A	isArrayLike()	0	4	2
A	hasErrors()	0	4	1
A	getErrors()	0	4	1
A	getValidators()	0	4	1
A	setValidators()	0	4	1
A	setTranslator()	0	4	1
A	__construct()	0	14	5
A	__invoke()	0	18	2
A	validate()	0	16	3
A	validateParam()	0	17	4
A	getTranslator()	0	4	1

<?php

namespace DavidePastore\Slim\Validation;

use Respect\Validation\Exceptions\NestedValidationException;
use Respect\Validation\Validator;

/**
 * Validation for Slim.
 */
class Validation
{
    /**
     * Validators.
     *
     * @var array
     */
    protected $validators = [];

    /**
     * Options.
     *
     * @var array
     */
    protected $options = [
    ];

    /**
     * The translator to use fro the exception message.
     *
     * @var callable
     */
    protected $translator = null;

    /**
     * Errors from the validation.
     *
     * @var array
     */
    protected $errors = [];

    /**
     * The 'errors' attribute name.
     *
     * @var string
     */
    protected $errors_name = 'errors';

    /**
     * The 'has_error' attribute name.
     *
     * @var string
     */
    protected $has_errors_name = 'has_errors';

    /**
     * The 'validators' attribute name.
     *
     * @var string
     */
    protected $validators_name = 'validators';

    /**
     * The 'translator' attribute name.
     *
     * @var string
     */
    protected $translator_name = 'translator';

    /**
     * Is the validators an instance of Validator?
     *
     * @var boolean
     */
    protected $isValidator = false;

    /**
     * Create new Validator service provider.
     *
     * @param null|array|ArrayAccess $validators
     * @param null|callable          $translator
     * @param []|array               $options

The doc-type []|array could not be parsed: Unknown type name "" at position 0. [(view supported doc-types)

     */
    public function __construct($validators = null, $translator = null, $options = [])
    {
        // Set the validators
        if (is_array($validators) || $validators instanceof \ArrayAccess) {
            $this->validators = $validators;
        } elseif ($validators instanceof Validator) {
            $this->validators = $validators;
            $this->isValidator = true;
        } elseif (is_null($validators)) {
            $this->validators = [];
        }
        $this->translator = $translator;
        $this->options = array_merge($this->options, $options);
    }

    /**
     * Validation middleware invokable class.
     *
     * @param \Psr\Http\Message\ServerRequestInterface $request  PSR7 request
     * @param \Psr\Http\Message\ResponseInterface      $response PSR7 response
     * @param callable                                 $next     Next middleware
     *
     * @return \Psr\Http\Message\ResponseInterface
     */
    public function __invoke($request, $response, $next)
    {
        $this->errors = [];
        $params = $request->getParams();

It seems like you code against a concrete implementation and not the interface Psr\Http\Message\ServerRequestInterface as the method getParams() does only exist in the following implementations of said interface: Slim\Http\Request.

        $params = array_merge((array) $request->getAttribute('routeInfo')[2], $params);
        if ($this->isValidator) {
            $this->validateParam($params, $this->validators);

$params is of type array, but the function expects a object<DavidePastore\Slim\Validation\any>.

$this->validators is of type array, but the function expects a object<DavidePastore\Slim\Validation\any>.

        } else {
            $this->validate($params, $this->validators);
        }

        $request = $request->withAttribute($this->errors_name, $this->getErrors());
        $request = $request->withAttribute($this->has_errors_name, $this->hasErrors());
        $request = $request->withAttribute($this->validators_name, $this->getValidators());
        $request = $request->withAttribute($this->translator_name, $this->getTranslator());

        return $next($request, $response);
    }

    /**
     * Validate the parameters by the given params, validators and actual keys.
     * This method populates the $errors attribute.
     *
     * @param array $params     The array of parameters.
     * @param array $validators The array of validators.
     * @param array $actualKeys An array that will save all the keys of the tree to retrieve the correct value.
     */
    private function validate($params = [], $validators = [], $actualKeys = [])
    {
        //Validate every parameters in the validators array
        foreach ($validators as $key => $validator) {
            $actualKeys[] = $key;
            $param = $this->getNestedParam($params, $actualKeys);
            if (is_array($validator)) {
                $this->validate($params, $validator, $actualKeys);
            } else {
                $this->validateParam($param, $validator, $actualKeys);
            }

            //Remove the key added in this foreach
            array_pop($actualKeys);
        }
    }

    /**
     * Validate a param.
     * @param any $param The parameter to validate.
     * @param any $validator The validator to use to validate the given parameter.
     * @param array $actualKeys An array with the position of the parameter.
     */
    private function validateParam($param, $validator, $actualKeys = [])
    {
        try {
            $validator->assert($param);
        } catch (NestedValidationException $exception) {
            if ($this->translator) {
                $exception->setParam('translator', $this->translator);
            }

            $messages = $exception->getMessages();
            if (empty($actualKeys)) {
                $this->errors = $messages;
            } else {
                $this->errors[implode('.', $actualKeys)] = $messages;
            }
        }
    }

    /**
     * Get the nested parameter value.
     *
     * @param array $params An array that represents the values of the parameters.
     * @param array $keys   An array that represents the tree of keys to use.
     *
     * @return mixed The nested parameter value by the given params and tree of keys.
     */
    private function getNestedParam($params = [], $keys = [])
    {
        if (empty($keys)) {
            return $params;
        } else {
            $firstKey = array_shift($keys);
            if ($this->isArrayLike($params) && array_key_exists($firstKey, $params)) {
                $params = (array) $params;
                $paramValue = $params[$firstKey];

                return $this->getNestedParam($paramValue, $keys);
            } else {
                return;
            }
        }
    }

    /**
     * Check if the given $params is an array like variable.
     *
     * @param array $params The variable to check.
     *
     * @return boolean Returns true if the given $params parameter is array like.
     */
    private function isArrayLike($params)
    {
        return is_array($params) || $params instanceof \SimpleXMLElement;
    }

    /**
     * Check if there are any errors.
     *
     * @return bool
     */
    public function hasErrors()
    {
        return !empty($this->errors);
    }

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

    /**
     * Get validators.
     *
     * @return array The validators array.
     */
    public function getValidators()
    {
        return $this->validators;
    }

    /**
     * Set validators.
     *
     * @param array $validators The validators array.
     */
    public function setValidators($validators)
    {
        $this->validators = $validators;
    }

    /**
     * Get translator.
     *
     * @return callable The translator.
     */
    public function getTranslator()
    {
        return $this->translator;
    }

    /**
     * Set translator.
     *
     * @param callable $translator The translator.
     */
    public function setTranslator($translator)
    {
        $this->translator = $translator;
    }
}