PhalconExt\Validation\Validation

Complexity

Total Complexity

42

Size/Duplication

Total Lines	364
Duplicated Lines	0 %

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	getErrorMessages()	0	13	2
A	pass()	0	3	1
A	fail()	0	3	1
A	register()	0	13	3
A	getHandler()	0	16	4
A	registerRules()	0	7	2
A	preChecking()	0	5	1
A	run()	0	19	3
A	getCurrentValue()	0	3	1
A	addRules()	0	17	4
A	__call()	0	3	1
A	attributeRules()	0	15	3
A	normalizeRules()	0	11	3
A	parseRules()	0	15	3
A	parseOptions()	0	14	3
A	cancelOnFail()	0	12	3
A	prepareDate()	0	15	4

<?php

namespace PhalconExt\Validation;

use Phalcon\Validation as BaseValidation;

The type Phalcon\Validation was not found. Maybe you did not declare it correctly or list all dependencies?

use Phalcon\Validation\Validator;

The type Phalcon\Validation\Validator was not found. Maybe you did not declare it correctly or list all dependencies?

use Phalcon\Validation\ValidatorInterface;

The type Phalcon\Validation\ValidatorInterface was not found. Maybe you did not declare it correctly or list all dependencies?

use PhalconExt\Validators;

The type PhalconExt\Validators was not found. Maybe you did not declare it correctly or list all dependencies?

/**
 * Phalcon Validation with batteries.
 *
 * @author  Jitendra Adhikari <jiten.adhikary@gmail.com>
 * @license MIT
 *
 * @link    https://github.com/adhocore/phalcon-ext
 */
class Validation extends BaseValidation
{
    /** @var array The alias of available validators */
    protected $validators = [
        'alnum'        => Validator\Alnum::class,

The type Phalcon\Validation\Validator\Alnum was not found. Maybe you did not declare it correctly or list all dependencies?

        'alpha'        => Validator\Alpha::class,

The type Phalcon\Validation\Validator\Alpha was not found. Maybe you did not declare it correctly or list all dependencies?

        'between'      => Validator\Between::class,

The type Phalcon\Validation\Validator\Between was not found. Maybe you did not declare it correctly or list all dependencies?

        'confirmation' => Validator\Confirmation::class,

The type Phalcon\Validation\Validator\Confirmation was not found. Maybe you did not declare it correctly or list all dependencies?

        'creditcard'   => Validator\CreditCard::class,

The type Phalcon\Validation\Validator\CreditCard was not found. Maybe you did not declare it correctly or list all dependencies?

        'date'         => Validator\Date::class,

The type Phalcon\Validation\Validator\Date was not found. Maybe you did not declare it correctly or list all dependencies?

        'digit'        => Validator\Digit::class,

The type Phalcon\Validation\Validator\Digit was not found. Maybe you did not declare it correctly or list all dependencies?

        'email'        => Validator\Email::class,

The type Phalcon\Validation\Validator\Email was not found. Maybe you did not declare it correctly or list all dependencies?

        'not_in'       => Validator\ExclusionIn::class,

The type Phalcon\Validation\Validator\ExclusionIn was not found. Maybe you did not declare it correctly or list all dependencies?

        'file'         => Validator\File::class,

The type Phalcon\Validation\Validator\File was not found. Maybe you did not declare it correctly or list all dependencies?

        'identical'    => Validator\Identical::class,

The type Phalcon\Validation\Validator\Identical was not found. Maybe you did not declare it correctly or list all dependencies?

        'in'           => Validator\InclusionIn::class,

The type Phalcon\Validation\Validator\InclusionIn was not found. Maybe you did not declare it correctly or list all dependencies?

        'numeric'      => Validator\Numericality::class,

The type Phalcon\Validation\Validator\Numericality was not found. Maybe you did not declare it correctly or list all dependencies?

        'required'     => Validator\PresenceOf::class,

The type Phalcon\Validation\Validator\PresenceOf was not found. Maybe you did not declare it correctly or list all dependencies?

        'regex'        => Validator\Regex::class,

The type Phalcon\Validation\Validator\Regex was not found. Maybe you did not declare it correctly or list all dependencies?

        'length'       => Validator\StringLength::class,

The type Phalcon\Validation\Validator\StringLength was not found. Maybe you did not declare it correctly or list all dependencies?

        'unique'       => Validator\Uniqueness::class,

The type Phalcon\Validation\Validator\Uniqueness was not found. Maybe you did not declare it correctly or list all dependencies?

        'url'          => Validator\Url::class,

The type Phalcon\Validation\Validator\Url was not found. Maybe you did not declare it correctly or list all dependencies?

        'exist'        => Existence::class,
    ];

    /** @var array The custom validation callbacks */
    protected $callbacks = [];

    /** @var ValidatorInterface The currently validating Validator. */
    protected $validator;

    /**
     * Register a custom validation rule.
     *
     * @param string             $ruleName
     * @param callable|Validator $handler
     * @param string             $message  Message to use when validation fails
     *
     * @return self
     */
    public function register(string $ruleName, $handler, string $message = ''): self
    {
        if (isset($this->validators[$ruleName])) {
            return $this;
        }

        if ($message) {
            $this->_defaultMessages += [$ruleName => $message];
        }

        $this->validators[$ruleName] = $this->getHandler($ruleName, $handler);

        return $this;
    }

    /**
     * Get validation handler description].
     *
     * @param string $ruleName
     * @param mixed  $handler
     *
     * @return string
     */
    protected function getHandler(string $ruleName, $handler)
    {
        if ($handler instanceof \Closure) {
            $handler = \Closure::bind($handler, $this);
        }

        if (\is_callable($handler)) {
            $this->callbacks[$ruleName] = $handler;
            $handler                    = Validator\Callback::class;

The type Phalcon\Validation\Validator\Callback was not found. Maybe you did not declare it correctly or list all dependencies?

        }

        if (!\is_subclass_of($handler, Validator::class)) {
            throw new \InvalidArgumentException('Unsupported validation rule: ' . $ruleName);
        }

        return $handler;

The expression return $handler also could return the type Closure which is incompatible with the documented return type string.

    }

    /**
     * Registers multiple custom validation rules at once!
     *
     * @param array $ruleHandlers ['rule1' => <handler>, ...]
     * @param array $messages     ['rule1' => 'message', ...]
     *
     * @return self
     */
    public function registerRules(array $ruleHandlers, array $messages = []): self
    {
        foreach ($ruleHandlers as $ruleName => $handler) {
            $this->register($ruleName, $handler, $messages[$ruleName] ?? '');
        }

        return $this;
    }

    /**
     * Check if the validation passes.
     *
     * @return bool
     */
    public function pass(): bool
    {
        return \count($this->_messages) === 0;
    }

    /**
     * Check if the validation fails.
     *
     * @return bool
     */
    public function fail(): bool
    {
        return !$this->pass();
    }

    /**
     * Get the error messages.
     *
     * @return array
     */
    public function getErrorMessages(): array
    {
        $messages = [];

        foreach ($this->_messages as $message) {
            $messages[] = [
                'code'    => $message->getCode(),
                'message' => $message->getMessage(),
                'field'   => $message->getField(),
            ];
        }

        return $messages;
    }

    /**
     * self validation with given ruleSet against given arbitrary dataSet.
     *
     * @param array        $ruleSet
     * @param array|object $dataSet
     *
     * @return self
     */
    public function run(array $ruleSet, $dataSet): self
    {
        $this->_messages = $this->_validators = [];

The property _validators does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

The property _messages does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        // See if it is arrayable!
        if (\is_object($dataSet)) {
            $dataSet = $this->prepareDate($dataSet);
        }

        // OK, must be entity!
        if (\is_object($dataSet)) {
            $this->_entity = $dataSet;

The property _entity does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        } else {
            $this->_data = $dataSet;

The property _data does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        $this->addRules($ruleSet)->validate();

        return $this;
    }

    /**
     * Prepare data &/or entity.
     *
     * @param array|object $dataSet
     *
     * @return array|object
     */
    protected function prepareDate($dataSet)
    {
        if ($dataSet instanceof \stdClass) {
            return (array) $dataSet;
        }

        if (\method_exists($dataSet, 'toArray')) {
            return $dataSet->toArray();
        }

        if (\method_exists($dataSet, 'getData')) {
            return $dataSet->getData();
        }

        return $dataSet;
    }

    /**
     * Run the validation rules on data set.
     *
     * @param array $ruleSet
     *
     * @return self
     */
    protected function addRules(array $ruleSet): self
    {
        foreach ($ruleSet as $attribute => $rules) {
            $rules = $this->normalizeRules($rules);

            // Only validate if attribute exists in dataSet when so configured.
            if (isset($rules['if_exist']) && null === $this->getValue($attribute)) {
                continue;
            }

            $rules = $this->cancelOnFail($rules);

            unset($rules['if_exist']);
            $this->attributeRules($attribute, $rules);
        }

        return $this;
    }

    /**
     * Make the validator cancel on fail i.e bail on first ever invalid field.
     *
     * @param array $rules
     *
     * @return array
     */
    protected function cancelOnFail(array $rules): array
    {
        if (!isset($rules['abort'])) {
            return $rules;
        }

        unset($rules['abort']);
        foreach ($rules as &$rule) {
            $rule = (array) $rule + ['cancelOnFail' => true];
        }

        return $rules;
    }

    /**
     * Normalize rules if needed.
     *
     * @param mixed $rules
     *
     * @return array
     */
    protected function normalizeRules($rules): array
    {
        if (\is_string($rules)) {
            return $this->parseRules($rules);
        }

        if (!\is_array($rules)) {
            throw new \UnexpectedValueException('The rules should be an array or string');
        }

        return $rules;
    }

    /**
     * Parse string representation of the rules and make it array.
     *
     * Rule Format: `rule1:key1:value11,value12;key2:value22|rule2:key21:value21|rule3`
     *
     * @param string $rules Example: 'required|length:min:1;max:2;|in:domain:1,12,30'
     *
     * @return array
     */
    protected function parseRules(string $rules): array
    {
        $parsed = [];

        foreach (\explode('|', $rules) as $rule) {
            if (false === \strpos($rule, ':')) {
                $parsed[$rule] = [];
                continue;
            }

            list($name, $options) = \explode(':', $rule, 2);
            $parsed[$name]        = $this->parseOptions($options);
        }

        return $parsed;
    }

    /**
     * Parse rule options.
     *
     * @param string $options
     *
     * @return array
     */
    protected function parseOptions(string $options): array
    {
        $parsed = [];

        foreach (\explode(';', $options) as $parts) {
            list($key, $value) = \explode(':', $parts) + ['', ''];
            if (\strpos($value, ',')) {
                $value = \explode(',', $value);
            }

            $parsed[$key] = $value;
        }

        return $parsed;
    }

    /**
     * Add all the rules for given attribute to validators list.
     *
     * @param string $attribute
     * @param array  $rules
     *
     * @return void
     */
    protected function attributeRules(string $attribute, array $rules)
    {
        foreach ($rules as $rule => $options) {
            if (!isset($this->validators[$rule])) {
                throw new \InvalidArgumentException('Unknown validation rule: ' . $rule);
            }

            $validator = $this->validators[$rule];
            $options   = (array) $options + [
                'callback' => $this->callbacks[$rule] ?? null,
                'message'  => $this->_defaultMessages[$rule] ?? null,
                '__field'  => $attribute,
            ];

            $this->add($attribute, new $validator($options));
        }
    }

    /**
     * {@inheritdoc}
     */
    protected function preChecking($field, ValidatorInterface $validator): bool
    {
        $this->validator = $validator;

        return parent::preChecking($field, $validator);
    }

    /**
     * Get current value being validated.
     *
     * @return mixed
     */
    public function getCurrentValue()
    {
        return $this->getValue($this->validator->getOption('__field'));
    }

    /**
     * Delegate calls to current validator.
     *
     * @param string $method
     * @param mixed  $args
     *
     * @return mixed
     */
    public function __call($method, $args)
    {
        return $this->validator->$method(...$args);
    }
}