Fyuze\Validator\Validator

Complexity

Total Complexity

16

Size/Duplication

Total Lines	130
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	required()	0	3	1
A	buildRule()	0	9	2
A	__construct()	0	4	1
A	validate()	0	9	4
A	passes()	0	3	1
A	min()	0	3	1
A	parseRule()	0	14	3
A	getErrors()	0	3	1
A	max()	0	3	1
A	failed()	0	3	1

<?php
namespace Fyuze\Validator;

class Validator
{
    /**
     * @var array
     */
    protected $input;

    /**
     * @var array
     */
    protected $rules;

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

    /**
     * Validator constructor.
     * @param array $input
     * @param array $rules
     */
    public function __construct(array $input = [], array $rules = [])
    {
        $this->input = $input + array_fill_keys(array_keys($rules), null);
        $this->rules = $rules;
    }

    /**
     * @return bool
     */
    public function passes()
    {
        return $this->validate();
    }

    /**
     * @return bool
     */
    public function failed()
    {
        return !$this->validate();
    }

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

    /**
     * @return bool
     */
    protected function validate()
    {
        foreach ($this->input as $key => $input) {
            if (array_key_exists($key, $this->rules) && $rule = $this->parseRule($key, $input)) {
                $this->errors[] = $rule;
            }
        }

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

    /**
     * @param $key
     * @param $value
     * @return bool|string
     */
    protected function parseRule($key, $value)
    {
        $params = [$value];

        foreach (explode('|', $this->rules[$key]) as $rule) {

            list($rule, $params) = $this->buildRule($rule, $params);

            if (call_user_func_array([$this, $rule], $params) === false) {
                return sprintf('Error with rule %s on field %s with %s', $rule, $key, implode(',', $params));
            }
        }

        return false;
    }

    /**
     * @param $rule
     * @param $params
     * @return array
     */
    protected function buildRule($rule, $params)
    {
        if (strpos($rule, ':') !== false) {
            $data = explode(':', $rule);
            $params[] = array_pop($data);
            $rule = reset($data);
        }

        return [$rule, $params];
    }

    /**
     * @param $value
     * @return bool
     */
    protected function required($value)
    {
        return !empty($value);
    }

    /**
     * @param $value
     * @param $max
     * @return bool
     */
    protected function max($value, $max)
    {
        return strlen($value) <= $max;
    }

    /**
     * @param $value
     * @param $min
     * @return bool
     */
    protected function min($value, $min)
    {
        return strlen($value) >= $min;
    }
}