Runner\Validator\Validator

Complexity

Total Complexity

32

Size/Duplication

Total Lines	214
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	fails()	0	3	1
A	data()	0	3	1
A	messages()	0	3	1
A	runValidateRule()	0	5	2
A	__construct()	0	5	1
A	hasField()	0	17	4
A	formatRuleName()	0	9	1
A	__call()	0	9	2
A	addExtension()	0	9	3
B	validate()	0	20	8
A	parseRules()	0	9	6
A	getField()	0	10	2

<?php
/**
 * @author: RunnerLee
 * @email: runnerleer@gmail.com
 * @time: 17-2-20 15:22
 */

namespace Runner\Validator;

use BadMethodCallException;
use Runner\Validator\Concerns\MessagesAttributes;
use Runner\Validator\Concerns\ValidatesAttributes;

/**
 * Class Validator.
 */
class Validator
{
    use ValidatesAttributes, MessagesAttributes;

    /**
     * @var array
     */
    protected $data = [];

    /**
     * @var array
     */
    protected $ruleGroups = [];

    /**
     * @var array
     */
    protected $messages = [];

    /**
     * @var array
     */
    protected static $forceRules = ['Required', 'RequiredIf', 'RequiredWith', 'RequiredUnless', 'RequiredWithout'];

    /**
     * @var array
     */
    protected static $extensions = [];

    /**
     * @var array
     */
    protected static $extensionTemplates = [];

    /**
     * Validator constructor.
     *
     * @param array  $data
     * @param array  $rules
     * @param array  $customMessages
     * @param string $file
     */
    public function __construct(array $data, array $rules, array $customMessages = [], $file = __DIR__.'/messages/en.php')
    {
        $this->data = $data;
        $this->parseRules($rules);
        $this->loadMessageTemplate($file, $customMessages);
    }

    /**
     * @param $name
     * @param $callback
     * @param bool   $isForce
     * @param string $message
     */
    public static function addExtension($name, $callback, $isForce = false, $message = null)
    {
        $name = self::formatRuleName($name);

        self::$extensions[$name] = $callback;

        $isForce && self::$forceRules[] = $name;

        !empty($message) && (static::$extensionTemplates[$name] = $message);
    }

    /**
     * @return bool
     */
    public function validate()
    {
        foreach ($this->ruleGroups as $field => $rules) {
            if ($this->hasField($field)) {
                $value = $this->getField($field);
                foreach ($rules as $rule => $parameters) {
                    if (!$this->runValidateRule($rule, $field, $value, $parameters)) {
                        $this->messages[$field][$rule] = $this->buildMessage($rule, $field, $parameters);
                    }
                }
            } elseif ($forceRules = array_intersect(self::$forceRules, array_keys($rules))) {
                foreach ($forceRules as $rule) {
                    if (!$this->runValidateRule($rule, $field, null, $rules[$rule])) {
                        $this->messages[$field][$rule] = $this->buildMessage($rule, $field, $rules[$rule]);
                    }
                }
            }
        }

        return 0 === count($this->messages);
    }

    /**
     * @return array
     */
    public function fails()
    {
        return array_keys($this->messages);
    }

    /**
     * @return array
     */
    public function messages()
    {
        return $this->messages;
    }

    /**
     * @return array
     */
    public function data()
    {
        return $this->data;
    }

    /**
     * @param array $ruleGroups
     */
    protected function parseRules(array $ruleGroups)
    {
        $map = [];
        foreach ($ruleGroups as $field => $rules) {
            foreach (explode('|', $rules) as $rule) {
                list($rule, $parameters) = explode(':', (false === strpos($rule, ':') ? ($rule.':') : $rule), 2);
                !isset($map[$rule]) && $map[$rule] = self::formatRuleName($rule);
                $rule = $map[$rule];
                $this->ruleGroups[$field][$rule] = ('' === $parameters ? [] : explode(',', $parameters));
            }
        }
    }

    /**
     * @param $name
     *
     * @return string
     */
    protected static function formatRuleName($name)
    {
        return implode(
            '',
            array_map(
                function ($value) {
                    return ucfirst($value);
                },
                explode('_', $name)
            )
        );
    }

    /**
     * @param string $field
     *
     * @return bool
     */
    protected function hasField($field)
    {
        $field = explode('.', $field);
        $item = array_shift($field);
        if (!array_key_exists($item, $this->data)) {
            return false;
        }
        $value = $this->data[$item];

        foreach ($field as $item) {
            if (!array_key_exists($item, $value)) {
                return false;
            }
            $value = $value[$item];
        }

        return true;
    }

    /**
     * @param string $field
     *
     * @return mixed
     */
    protected function getField($field)
    {
        $field = explode('.', $field);
        $item = array_shift($field);
        $value = $this->data[$item];
        foreach ($field as $item) {
            $value = $value[$item];
        }

        return $value;
    }

    /**
     * @param $field
     * @param $value
     * @param $rule
     * @param array $parameters
     *
     * @return bool
     */
    protected function runValidateRule($rule, $field, $value, array $parameters = [])
    {
        $callback = array_key_exists($rule, self::$extensions) ? self::$extensions[$rule] : [$this, "validate{$rule}"];

        return (bool) call_user_func($callback, $field, $value, $parameters, $this);
    }

    public function __call($method, $arguments)
    {
        $rule = self::formatRuleName(substr($method, 8));

        if (!isset(self::$extensions[$rule])) {
            throw new BadMethodCallException(sprintf('Method %s::%s does not exists', static::class, $method));
        }

        return $this->runValidateRule($rule, ...$arguments);

The call to Runner\Validator\Validator::runValidateRule() has too few arguments starting with value.

    }
}