kalanis\Restful\Validation\Validator

Complexity

Total Complexity

23

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	validateUuid()	0	5	2
A	validateCallback()	0	10	4
A	validate()	0	16	4
A	parseExpression()	0	10	2
A	validateEquality()	0	4	2
A	validateRegexp()	0	8	3
A	validateRequired()	0	4	2
A	validateEmail()	0	4	2
A	validateUrl()	0	4	2

<?php

namespace kalanis\Restful\Validation;


use kalanis\Restful\Exceptions\InvalidArgumentException;
use kalanis\Restful\Exceptions\InvalidStateException;
use kalanis\Restful\Validation\Exceptions\ValidationException;
use Nette\Utils\Strings;
use Nette\Utils\Validators;


/**
 * Rule validator
 * @package kalanis\Restful\Validation
 */
class Validator implements IValidator
{

    /** @var array<string, array<string, string>|callable|callable-string> Command handle callbacks */

The doc comment array<string, array<string, string>|callable|callable-string> at position 13 could not be parsed: Unknown type name 'callable-string' at position 13 in array<string, array<string, string>|callable|callable-string>.

    public array $handle = [
        self::EMAIL => [self::class, 'validateEmail'],
        self::URL => [self::class, 'validateUrl'],
        self::REGEXP => [self::class, 'validateRegexp'],
        self::EQUAL => [self::class, 'validateEquality'],
        self::UUID => [self::class, 'validateUuid'],
        self::CALLBACK => [self::class, 'validateCallback'],
        self::REQUIRED => [self::class, 'validateRequired'],
    ];

    /**
     * Validate callback rule
     * @param string|int|float|null $value
     *
     * @throws  ValidationException If callback returns false
     */
    public static function validateCallback(mixed $value, Rule $rule): void
    {
        $arguments = $rule->getArgument();
        if (isset($arguments[0]) && is_callable($arguments[0])) {
            $result = $arguments[0]($value);
            if (true === $result) {
                return;
            }
        }
        throw ValidationException::createFromRule($rule, $value);
    }

    /**
     * Validate required rule
     * @param string|int|float|null $value
     *
     * @throws  ValidationException If field value is missing (is null)
     */
    public static function validateRequired(mixed $value, Rule $rule): void
    {
        if (is_null($value)) {
            throw ValidationException::createFromRule($rule, $value);
        }
    }

    /******************** Special validators ********************/
    /**
     * Validate regexp
     *
     * @throws InvalidArgumentException
     * @throws ValidationException
     */
    public static function validateRegexp(mixed $value, Rule $rule): void
    {
        if (!isset($rule->getArgument()[0])) {
            throw new InvalidArgumentException('No regular expression found in pattern validation rule');
        }

        if (!Strings::match(strval($value), strval($rule->getArgument()[0]))) {

Are you sure the usage of Nette\Utils\Strings::match(strval($value), strval($rule->getArgument()[0])) targeting Nette\Utils\Strings::match() seems to always return null.

            throw ValidationException::createFromRule($rule, $value);
        }
    }

    /**
     * Validate equality
     * @param string $value
     * @throws ValidationException
     */
    public static function validateEquality(mixed $value, Rule $rule): void
    {
        if (!in_array(strval($value), $rule->getArgument())) {
            throw ValidationException::createFromRule($rule, $value);
        }
    }

    /**
     * Validate email
     * @param string $value
     * @throws ValidationException
     */
    public static function validateEmail(mixed $value, Rule $rule): void
    {
        if (!Validators::isEmail(strval($value))) {
            throw ValidationException::createFromRule($rule, $value);
        }
    }

    /**
     * Validate URL
     * @param string $value
     * @throws ValidationException
     */
    public static function validateUrl(mixed $value, Rule $rule): void
    {
        if (!Validators::isUrl(strval($value))) {
            throw ValidationException::createFromRule($rule, $value);
        }
    }

    /**
     * Validate UUID
     * @param string $value
     * @throws ValidationException
     */
    public static function validateUuid(mixed $value, Rule $rule): void
    {
        $isUuid = (bool) preg_match("/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i", strval($value));
        if (!$isUuid) {
            throw ValidationException::createFromRule($rule, $value);
        }
    }

    /**
     * Validate value for this rule
     * @param mixed $value
     * @param Rule $rule
     * @throws InvalidStateException
     * @throws ValidationException
     * @return void
     */
    public function validate(mixed $value, Rule $rule): void
    {
        if (isset($this->handle[$rule->getExpression()])) {
            $callback = $this->handle[$rule->getExpression()];
            if (!is_callable($callback)) {
                throw new InvalidStateException(
                    'Handle for expression ' . $rule->getExpression() . ' not found or is not callable');
            }
            $params = [$value, $rule];
            call_user_func_array($callback, $params);
            return;
        }

        $expression = $this->parseExpression($rule);
        if (!Validators::is($value, $expression)) {
            throw ValidationException::createFromRule($rule, $value);
        }
    }

    /**
     * Parse nette validator expression
     */
    private function parseExpression(Rule $rule): string
    {
        $givenArgumentsCount = count($rule->getArgument());
        $expectedArgumentsCount = substr_count($rule->getExpression(), '%');
        if ($expectedArgumentsCount != $givenArgumentsCount) {
            throw new InvalidArgumentException(
                'Invalid number of arguments for expression "' . $rule->getExpression() . '". Expected ' . $expectedArgumentsCount . ', ' . $givenArgumentsCount . ' given.'
            );
        }
        return vsprintf($rule->getExpression(), $rule->getArgument());
    }
}