Validoo\Validator

Complexity

Total Complexity

70

Size/Duplication

Total Lines	459
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	1

Test Coverage

Coverage

78.38%

Importance

Changes

0

31 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
C	validate()	0	41	11
A	doValidation()	0	18	4
A	getParams()	0	13	2
A	getParamValues()	0	9	3
A	required()	0	9	4
A	numeric()	0	4	1
A	email()	0	4	1
A	isdir()	0	4	1
A	isarray()	0	4	1
A	integer()	0	4	2
A	float()	0	4	2
A	alpha()	0	4	1
A	alpha_numeric()	0	4	1
A	ip()	0	4	1
A	url()	0	4	1
A	max_length()	0	4	1
A	min_length()	0	4	1
A	exact_length()	0	4	1
A	equals()	0	4	1
A	is_filename()	0	4	1
A	exists_file()	0	4	1
A	isSuccess()	0	4	1
A	customErrors()	0	12	3
D	getErrors()	0	45	10
A	getDefaultLang()	0	4	1
A	getDefaultErrorTexts()	0	15	3
A	handleNaming()	0	10	2
A	handleParameterNaming()	0	14	4
A	has()	0	8	2
A	getResults()	0	4	1

<?php

namespace Validoo;

/**
 * Validator Class
 * @author Alessandro Manno <alessandro.manno@facile.it>
 * @author Chiara Ferrazza <chiara.ferrazza@facile.it>
 * @copyright (c) 2016, Facile.it
 * @license https://github.com/facile-it/validoo/blob/master/LICENSE MIT Licence
 * @link https://github.com/facile-it/validoo
 */

/**
 * TODO: Exception handling for rules with parameters
 * TODO: unit tests for numeric, float, alpha_numeric, max_length, min_length, exact_length
 * TODO: add protection filters for several input vulnerabilities.
 */
class Validator
{

    /** @var array */
    private $errors = [];
    /** @var array */
    private $namings = [];
    /** @var array */
    private $customErrorsWithInputName = [];
    /** @var array */
    private $customErrors = [];

    /**
     * Constructor is not allowed because Validoo uses its own
     * static method to instantiate the validation
     * @param $errors
     * @param $namings
     */
    private function __construct($errors, $namings)
    {
        $this->errors = $errors;
        $this->namings = $namings;
    }

    /**
     * @param $inputs
     * @param array $rules
     * @param array|null $naming
     * @return Validator
     * @throws ValidooException
     */
    public static function validate($inputs, array $rules, array $naming = null): self
    {
        $errors = null;
        foreach ($rules as $input => $input_rules) {

Blank line found at start of control structure

            if (is_string($input_rules))

It is generally a best practice to always use braces with control structures.

                $input_rules = explode("|", $input_rules);

            if (!is_array($input_rules))

It is generally a best practice to always use braces with control structures.

                throw new ValidooException(ValidooException::ARRAY_EXPECTED, $input);

            if (in_array("onlyifset", $input_rules) && !isset($inputs[$input]))

It is generally a best practice to always use braces with control structures.

                continue;

            foreach ($input_rules as $rule => $closure) {
                if (!isset($inputs[$input])) {
                    $input_value = null;
                } else {
                    $input_value = $inputs[$input];
                }
                if (is_numeric($rule)) {
                    $rule = $closure;
                }
                if ('onlyifset' == $rule)

It is generally a best practice to always use braces with control structures.

                    continue;

                $rule_and_params = self::getParams($rule);
                $params = $real_params = $rule_and_params['params'];
                $rule = $rule_and_params['rule'];
                $params = self::getParamValues($params, $inputs);
                array_unshift($params, $input_value);

                if (false == self::doValidation($closure, $params, $rule)) {
                    $errors[$input][$rule]['result'] = false;
                    $errors[$input][$rule]['params'] = $real_params;
                }
            }

Blank line found at end of control structure

        }
        return new self($errors, $naming);
    }

    /**
     * @param $closure
     * @param $params
     * @param $rule
     * @return mixed
     * @throws ValidooException
     */
    private static function doValidation($closure, $params, $rule)
    {
        if (@get_class($closure) === 'Closure') {
            $refl_func = new \ReflectionFunction($closure);
            $validation = $refl_func->invokeArgs($params);
        } else if (@method_exists(get_called_class(), $rule)) {
            $refl = new \ReflectionMethod(get_called_class(), $rule);
            if ($refl->isStatic()) {
                $refl->setAccessible(true);
                $validation = $refl->invokeArgs(null, $params);
            } else {
                throw new ValidooException(ValidooException::STATIC_METHOD, $rule);
            }
        } else {
            throw new ValidooException(ValidooException::UNKNOWN_RULE, $rule);
        }
        return $validation;
    }

    /**
     * Gets the parameter names of a rule
     * @param $rule
     * @return mixed
     */
    private static function getParams($rule)
    {
        if (preg_match("#^([\w]+)\((.+?)\)$#", $rule, $matches)) {
            return [
                'rule' => $matches[1],
                'params' => explode(',', $matches[2])
            ];
        }
        return [
            'rule' => $rule,
            'params' => []
        ];
    }

    /**
     * Handle parameter with input name
     * eg: equals(:name)
     * @param mixed $params
     * @param $inputs
     * @return mixed
     */
    private static function getParamValues($params, $inputs)
    {
        foreach ($params as $key => $param) {
            if (preg_match("#^:([\w]+)$#", $param, $param_type)) {
                $params[$key] = @$inputs[(string)$param_type[1]];
            }
        }
        return $params;
    }

    /**
     * @param null $input
     * @return bool
     */
    protected static function required($input = null): bool
    {
        if (is_string($input))

It is generally a best practice to always use braces with control structures.

            $input = trim($input);
        if (is_numeric($input))

It is generally a best practice to always use braces with control structures.

            return true;

        return (null !== $input && !empty($input));
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function numeric($input): bool
    {
        return is_numeric($input);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function email($input): bool
    {
        return filter_var($input, FILTER_VALIDATE_EMAIL);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function isdir($input): bool
    {
        return is_dir($input);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function isarray($input): bool
    {
        return is_array($input);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function integer($input): bool
    {
        return is_int($input) || ($input == (string)(int)$input);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function float($input): bool
    {
        return is_float($input) || ($input == (string)(float)$input);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function alpha($input): bool
    {
        return (preg_match("#^[a-zA-ZÀ-ÿ]+$#", $input) == 1);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function alpha_numeric($input): bool

Method name "Validator::alpha_numeric" is not in camel caps format

    {
        return (preg_match("#^[a-zA-ZÀ-ÿ0-9]+$#", $input) == 1);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function ip($input): bool
    {
        return filter_var($input, FILTER_VALIDATE_IP);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function url($input): bool
    {
        return filter_var($input, FILTER_VALIDATE_URL);
    }

    /**
     * @param $input
     * @param $length
     * @return bool
     */
    protected static function max_length($input, $length): bool

Method name "Validator::max_length" is not in camel caps format

    {
        return (strlen($input) <= $length);
    }

    /**
     * @param $input
     * @param $length
     * @return bool
     */
    protected static function min_length($input, $length): bool

Method name "Validator::min_length" is not in camel caps format

    {
        return (strlen($input) >= $length);
    }

    /**
     * @param $input
     * @param $length
     * @return bool
     */
    protected static function exact_length($input, $length): bool

Method name "Validator::exact_length" is not in camel caps format

    {
        return (strlen($input) == $length);
    }

    /**
     * @param $input
     * @param $param
     * @return bool
     */
    protected static function equals($input, $param): bool
    {
        return ($input == $param);
    }

    /**
     * @param $input
     * @return bool
     */
    protected static function is_filename($input): bool

Method name "Validator::is_filename" is not in camel caps format

    {
        return preg_match('/^[A-Za-z0-9-_]+[.]{1}[A-Za-z0-9]+$/', $input);
    }

    protected static function exists_file($input): bool

Method name "Validator::exists_file" is not in camel caps format

    {
        return file_exists($input);
    }

    /**
     * @return bool
     */
    public function isSuccess()
    {
        return empty($this->errors);
    }

    /**
     * @param array $errors_array
     */
    public function customErrors(array $errors_array)
    {
        foreach ($errors_array as $key => $value) {
            // handle input.rule eg (name.required)
            if (preg_match("#^(.+?)\.(.+?)$#", $key, $matches)) {
                // $this->customErrorsWithInputName[name][required] = error message
                $this->customErrorsWithInputName[(string)$matches[1]][(string)$matches[2]] = $value;
            } else {
                $this->customErrors[(string)$key] = $value;
            }
        }
    }

    /**
     * @param string|null $lang
     * @return array
     * @throws ValidooException
     */
    public function getErrors(string $lang = null): array
    {
        if (null === $lang) {
            $lang = $this->getDefaultLang();
        }

        $error_results = [];
        $default_error_texts = $this->getDefaultErrorTexts($lang);

        foreach ($this->errors as $input_name => $results) {
            foreach ($results as $rule => $result) {
                $named_input = $this->handleNaming($input_name);
                /**
                 * if parameters are input name they should be named as well
                 */
                $result['params'] = $this->handleParameterNaming($result['params']);
                // if there is a custom message with input name, apply it
                if (isset($this->customErrorsWithInputName[(string)$input_name][(string)$rule])) {
                    $error_message = $this->customErrorsWithInputName[(string)$input_name][(string)$rule];
                } // if there is a custom message for the rule, apply it
                else if (isset($this->customErrors[(string)$rule])) {
                    $error_message = $this->customErrors[(string)$rule];
                } // if there is a custom validator try to fetch from its error file
                else if (isset($custom_error_texts[(string)$rule])) {
                    $error_message = $custom_error_texts[(string)$rule];
                } // if none try to fetch from default error file
                else if (isset($default_error_texts[(string)$rule])) {
                    $error_message = $default_error_texts[(string)$rule];
                } else {
                    throw new ValidooException(ValidooException::NO_ERROR_TEXT, $rule);
                }
                /**
                 * handle :params(..)
                 */
                if (preg_match_all("#:params\((.+?)\)#", $error_message, $param_indexes)) {
                    foreach ($param_indexes[1] as $param_index) {
                        $error_message = str_replace(':params(' . $param_index . ')', $result['params'][$param_index], $error_message);
                    }
                }
                $error_results[] = str_replace(':attribute', $named_input, $error_message);
            }
        }

        return $error_results;
    }

    /**
     * @return string
     */
    protected function getDefaultLang(): string
    {
        return 'en';
    }

    /*
     * TODO: need improvements for tel and urn urls.
     * check out url.test.php for the test result
     * urn syntax: http://www.faqs.org/rfcs/rfc2141.html
     *
     */

    /**
     * @param string|null $lang
     * @return array|mixed
     */
    protected function getDefaultErrorTexts(string $lang = null)
    {
        /* handle default error text file */
        $default_error_texts = [];
        if (file_exists(__DIR__ . '/errors/' . $lang . '.php')) {
            /** @noinspection PhpIncludeInspection */
            $default_error_texts = include __DIR__ . '/errors/' . $lang . '.php';
        }
        if (file_exists(__DIR__ . '/errors/' . $lang . '.json')) {
            $default_error_texts = json_decode(file_get_contents(__DIR__ . '/errors/' . $lang . '.json'), true);
        }


        return $default_error_texts;
    }

    /**
     * @param string $input_name
     * @return mixed|string
     */
    protected function handleNaming(string $input_name)
    {
        if (isset($this->namings[$input_name])) {
            $named_input = $this->namings[$input_name];
        } else {
            $named_input = $input_name;
        }

        return $named_input;
    }

    /**
     * @param array $params
     * @return array
     */
    protected function handleParameterNaming(array $params)
    {
        foreach ($params as $key => $param) {
            if (preg_match("#^:([\w]+)$#", $param, $param_type)) {
                if (isset($this->namings[(string)$param_type[1]])) {
                    $params[$key] = $this->namings[(string)$param_type[1]];
                } else {
                    $params[$key] = $param_type[1];
                }
            }
        }

        return $params;
    }

    /**
     * @param string $input_name
     * @param string|null $rule_name
     * @return bool
     */
    public function has(string $input_name, string $rule_name = null): bool
    {
        if (null !== $rule_name) {
            return isset($this->errors[$input_name][$rule_name]);
        }

        return isset($this->errors[$input_name]);
    }

    /**
     * @return array
     */
    final public function getResults(): array
    {
        return $this->errors;
    }
}