Validator::errors()   A
last analyzed

Complexity

Conditions 3
Paths 2

Size

Total Lines 7
Code Lines 3

Duplication

Lines 0
Ratio 0 %

Importance

Changes 1
Bugs 0 Features 0
Metric Value
eloc 3
c 1
b 0
f 0
dl 0
loc 7
rs 10
cc 3
nc 2
nop 1
1
<?php
2
3
namespace Cube\SilverStripe\Validation;
4
5
use Exception;
6
7
/**
8
 * Class Validator
9
 * @package Cube\SilverStripe\Validation
10
 */
11
class Validator
12
{
13
    /**
14
     * @var array
15
     */
16
    private $data;
17
18
    /**
19
     * @var array
20
     */
21
    private $rules;
22
23
    /**
24
     * @var
25
     */
26
    private $customMessages = [];
27
28
    /**
29
     * @var array
30
     */
31
    private $errors = [];
32
33
    /**
34
     * Validator constructor.
35
     *
36
     * @param array $data
37
     * @param array $rules
38
     */
39
    public function __construct(array $data = [], array $rules = [])
40
    {
41
        $this->data = $data;
42
        $this->rules = ValidationRuleParser::make($rules)->getData();
43
    }
44
45
    /**
46
     * Validate
47
     * @throws Exception
48
     */
49
    public function validate()
50
    {
51
        foreach ($this->rules as $field => $rules) {
52
            foreach ($rules as $rule => $arguments) {
53
                $this->validateField($rule, $field, $arguments);
54
            }
55
        }
56
57
        return count($this->errors()) === 0;
58
    }
59
60
    /**
61
     * @param array $messages
62
     */
63
    public function setCustomMessages(array $messages)
64
    {
65
        $this->customMessages = $messages;
66
    }
67
68
    /**
69
     * @param string $rule
70
     * @param string $field
71
     * @param array $arguments
72
     * @throws Exception
73
     */
74
    private function validateField(string $rule, string $field, array $arguments = [])
75
    {
76
        $validationRule = ValidationRules::get($rule);
77
        $value = $this->getValue($field);
78
79
        if (!$validationRule->passes($value, $arguments)) {
80
            // The value did not meet the rules requirements
81
            $this->addError($rule, $field, $arguments);
82
        }
83
    }
84
85
    /**
86
     * @param string $rule
87
     * @param string $field
88
     * @param array $arguments
89
     */
90
    private function addError(string $rule, string $field, array $arguments = [])
91
    {
92
        $arguments = count($arguments) > 0 ? [$rule => $arguments[0]] : [];
93
94
        $message = MessageProvider::make($rule, $field, $arguments, $this->customMessages);
95
96
        $this->errors[$field][] = $message->get();
97
    }
98
99
    /**
100
     * @param string $field
101
     * @return array
102
     */
103
    public function errors(string $field = '')
104
    {
105
        if ($field && isset($this->errors[$field])) {
106
            return $this->errors[$field];
107
        }
108
109
        return $this->errors;
110
    }
111
112
    /**
113
     * @param string $field
114
     * @return mixed|null
115
     */
116
    private function getValue(string $field)
117
    {
118
        return isset($this->data[$field]) ? $this->data[$field] : null;
119
    }
120
121
    /**
122
     * @param array $data
123
     * @param array $rules
124
     * @return static
125
     */
126
    public static function make(array $data = [], array $rules = [])
127
    {
128
        return new static($data, $rules);
129
    }
130
}
131