Completed
Push — master ( 8e9c3c...46228f )
by Rick
07:43 queued 05:16
created

Chain::regex()   A

Complexity

Conditions 1
Paths 1

Size

Total Lines 4
Code Lines 2

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 2
CRAP Score 1

Importance

Changes 1
Bugs 0 Features 0
Metric Value
c 1
b 0
f 0
dl 0
loc 4
ccs 2
cts 2
cp 1
rs 10
cc 1
eloc 2
nc 1
nop 1
crap 1
1
<?php
2
/**
3
 * Particle.
4
 *
5
 * @link      http://github.com/particle-php for the canonical source repository
6
 * @copyright Copyright (c) 2005-2015 Particle (http://particle-php.com)
7
 * @license   https://github.com/particle-php/validator/blob/master/LICENSE New BSD License
8
 */
9
namespace Particle\Validator;
10
11
use Particle\Validator\Output\Structure;
12
use Particle\Validator\Output\Subject;
13
use Particle\Validator\Value\Container;
14
15
/**
16
 * Represents a collection of Rules which may break the chain of validation (but usually don't).
17
 *
18
 * @package Particle\Validator
19
 */
20
class Chain
21
{
22
    /**
23
     * The key we want to validate.
24
     *
25
     * @var string
26
     */
27
    protected $key;
28
29
    /**
30
     * The name that we can use in error messages.
31
     *
32
     * @var string
33
     */
34
    protected $name;
35
36
    /**
37
     * The array of all rules for this chain.
38
     *
39
     * @var Rule[]
40
     */
41
    protected $rules = [];
42
43
    /**
44
     * The message stack to append messages to.
45
     *
46
     * @var MessageStack
47
     */
48
    protected $messageStack;
49
50
    /**
51
     * Construct the chain.
52
     *
53
     * @param string $key
54
     * @param string $name
55
     * @param bool $required
56
     * @param bool $allowEmpty
57
     */
58 151
    public function __construct($key, $name, $required, $allowEmpty)
59
    {
60 151
        $this->key = $key;
61 151
        $this->name = $name;
62
63 151
        $this->addRule(new Rule\Required($required));
64 151
        $this->addRule(new Rule\NotEmpty($allowEmpty));
65 151
    }
66
67
    /**
68
     * Overwrite the default __clone behaviour to make sure the rules are cloned too.
69
     */
70 3
    public function __clone()
71
    {
72 3
        $rules = [];
73 3
        foreach ($this->rules as $rule) {
74 3
            $rules[] = clone $rule;
75 3
        }
76 3
        $this->rules = $rules;
77 3
    }
78
79
    /**
80
     * Validate the value to consist only out of alphanumeric characters.
81
     *
82
     * @param bool $allowWhitespace
83
     * @return $this
84
     */
85 7
    public function alnum($allowWhitespace = false)
86
    {
87 7
        return $this->addRule(new Rule\Alnum($allowWhitespace));
88
    }
89
90
    /**
91
     * Validate that the value only consists our of alphabetic characters.
92
     *
93
     * @param bool $allowWhitespace
94
     * @return $this
95
     */
96 7
    public function alpha($allowWhitespace = false)
97
    {
98 7
        return $this->addRule(new Rule\Alpha($allowWhitespace));
99
    }
100
101
    /**
102
     * Validate that the value is between $min and $max (inclusive).
103
     *
104
     * @param int $min
105
     * @param int $max
106
     * @return $this
107
     */
108 6
    public function between($min, $max)
109
    {
110 6
        return $this->addRule(new Rule\Between($min, $max));
111
    }
112
113
    /**
114
     * Validate that the value is a boolean.
115
     *
116
     * @return $this
117
     */
118 9
    public function bool()
119
    {
120 9
        return $this->addRule(new Rule\Boolean());
121
    }
122
123
    /**
124
     * Validate by executing a callback function, and returning its result.
125
     *
126
     * @param callable $callable
127
     * @return $this
128
     */
129 5
    public function callback(callable $callable)
130
    {
131 5
        return $this->addRule(new Rule\Callback($callable));
132
    }
133
134
    /**
135
     * Validates that the value is a date. If format is passed, it *must* be in that format.
136
     *
137
     * @param string|null $format
138
     * @return $this
139
     */
140 8
    public function datetime($format = null)
141
    {
142 8
        return $this->addRule(new Rule\Datetime($format));
143
    }
144
145
    /**
146
     * Validates that all characters of the value are decimal digits.
147
     *
148
     * @return $this
149
     */
150 4
    public function digits()
151
    {
152 4
        return $this->addRule(new Rule\Digits());
153
    }
154
155
    /**
156
     * Validates a value to be a nested array, which can then be validated using a new Validator instance.
157
     *
158
     * @param callable $callback
159
     * @return $this
160
     */
161 5
    public function each(callable $callback)
162
    {
163 5
        return $this->addRule(new Rule\Each($callback));
164
    }
165
166
    /**
167
     * Validates that the value is a valid email address (format only).
168
     * @return $this
169
     */
170 6
    public function email()
171
    {
172 6
        return $this->addRule(new Rule\Email());
173
    }
174
175
    /**
176
     * Validates that the value is equal to $value.
177
     *
178
     * @param string $value
179
     * @return $this
180
     */
181 2
    public function equals($value)
182
    {
183 2
        return $this->addRule(new Rule\Equal($value));
184
    }
185
186
    /**
187
     * Validates that the value is greater than $value.
188
     *
189
     * @param int $value
190
     * @return $this
191
     */
192 3
    public function greaterThan($value)
193
    {
194 3
        return $this->addRule(new Rule\GreaterThan($value));
195
    }
196
197
    /**
198
     * Validates that the value is in the array with optional "loose" checking.
199
     *
200
     * @param array $array
201
     * @param bool $strict
202
     * @return $this
203
     */
204 4
    public function inArray(array $array, $strict = true)
205
    {
206 4
        return $this->addRule(new Rule\InArray($array, $strict));
207
    }
208
209
    /**
210
     * Validates the value represents a valid integer
211
     *
212
     * @return $this
213
     * @see \Particle\Validator\Rule\Integer
214
     */
215 10
    public function integer()
216
    {
217 10
        return $this->addRule(new Rule\Integer());
218
    }
219
220
    /**
221
     * Validates that the value represents a valid JSON string
222
     *
223
     * @return $this
224
     * @see \Particle\Validator\Rule\Json
225
     */
226 11
    public function json()
227
    {
228 11
        return $this->addRule(new Rule\Json());
229
    }
230
231
    /**
232
     * Validate the value to be of precisely length $length.
233
     *
234
     * @param int $length
235
     * @return $this
236
     */
237 13
    public function length($length)
238
    {
239 13
        return $this->addRule(new Rule\Length($length));
240
    }
241
242
    /**
243
     * Validates that the length of the value is between $min and $max.
244
     *
245
     * If $max is null, it has no upper limit. The default is inclusive.
246
     *
247
     * @param int $min
248
     * @param int|null $max
249
     * @return $this
250
     */
251 7
    public function lengthBetween($min, $max)
252
    {
253 7
        return $this->addRule(new Rule\LengthBetween($min, $max));
254
    }
255
256
    /**
257
     * Validates that the value is less than $value.
258
     *
259
     * @param int $value
260
     * @return $this
261
     */
262 3
    public function lessThan($value)
263
    {
264 3
        return $this->addRule(new Rule\LessThan($value));
265
    }
266
267
    /**
268
     * Mount a rule object onto this chain.
269
     *
270
     * @param Rule $rule
271
     * @return $this
272
     */
273 1
    public function mount(Rule $rule)
274
    {
275 1
        return $this->addRule($rule);
276
    }
277
278
    /**
279
     * Validates that the value is either a integer or a float.
280
     *
281
     * @return $this
282
     */
283 11
    public function numeric()
284
    {
285 11
        return $this->addRule(new Rule\Numeric());
286
    }
287
288
    /**
289
     * Validates that the value matches the regular expression $regex.
290
     *
291
     * @param string $regex
292
     * @return $this
293
     */
294 2
    public function regex($regex)
295
    {
296 2
        return $this->addRule(new Rule\Regex($regex));
297
    }
298
299
    /**
300
     * Validates that the value is a valid URL. The schemes array is to selectively whitelist URL schemes.
301
     *
302
     * @param array $schemes
303
     * @return $this
304
     */
305 7
    public function url(array $schemes = [])
306
    {
307 7
        return $this->addRule(new Rule\Url($schemes));
308
    }
309
310
    /**
311
     * Validates that the value is a valid UUID
312
     *
313
     * @param int $version
314
     * @return $this
315
     */
316 12
    public function uuid($version = Rule\Uuid::UUID_V4)
317
    {
318 12
        return $this->addRule(new Rule\Uuid($version));
319
    }
320
321
    /**
322
     * Set a callable or boolean value which may be used to alter the required requirement on validation time.
323
     *
324
     * This may be incredibly helpful when doing conditional validation.
325
     *
326
     * @param callable|bool $required
327
     * @return $this
328
     */
329 5
    public function required($required)
330
    {
331 5
        $this->getRequiredRule()->setRequired($required);
332 5
        return $this;
333
    }
334
335
    /**
336
     * Set a callable or boolean value which may be used to alter the allow empty requirement on validation time.
337
     *
338
     * This may be incredibly helpful when doing conditional validation.
339
     *
340
     * @param callable|bool $allowEmpty
341
     * @return $this
342
     */
343 4
    public function allowEmpty($allowEmpty)
344
    {
345 4
        $this->getNotEmptyRule()->setAllowEmpty($allowEmpty);
346 4
        return $this;
347
    }
348
349
    /**
350
     * Attach a representation of this Chain to the Output\Structure $structure.
351
     *
352
     * @internal
353
     * @param Structure $structure
354
     * @param MessageStack $messageStack
355
     * @return Structure
356
     */
357 2
    public function output(Structure $structure, MessageStack $messageStack)
358
    {
359 2
        $subject = new Subject($this->key, $this->name);
360
361 2
        foreach ($this->rules as $rule) {
362 2
            $rule->output($subject, $messageStack);
363 2
        }
364
365 2
        $structure->addSubject($subject);
366
367 2
        return $structure;
368
    }
369
370
    /**
371
     * Validates the values in the $values array and appends messages to $messageStack. Returns the result as a bool.
372
     *
373
     * @param MessageStack $messageStack
374
     * @param Container $input
375
     * @param Container $output
376
     * @return bool
377
     */
378 148
    public function validate(MessageStack $messageStack, Container $input, Container $output)
379
    {
380 148
        $valid = true;
381 148
        foreach ($this->rules as $rule) {
382 148
            $rule->setMessageStack($messageStack);
383 148
            $rule->setParameters($this->key, $this->name);
384
385 148
            $valid = $rule->isValid($this->key, $input) && $valid;
386
387 148
            if ($rule->shouldBreakChain()) {
388 15
                break;
389
            }
390 148
        }
391
392 148
        if ($valid && $input->has($this->key)) {
393 81
            $output->set($this->key, $input->get($this->key));
394 81
        }
395 148
        return $valid;
396
    }
397
398
    /**
399
     * Shortcut method for storing a rule on this chain, and returning the chain.
400
     *
401
     * @param Rule $rule
402
     * @return $this
403
     */
404 151
    protected function addRule(Rule $rule)
405
    {
406 151
        $this->rules[] = $rule;
407
408 151
        return $this;
409
    }
410
411
    /**
412
     * Returns the first rule, which is always the required rule.
413
     *
414
     * @return Rule\Required
415
     */
416 5
    protected function getRequiredRule()
417
    {
418 5
        return $this->rules[0];
419
    }
420
421
    /**
422
     * Returns the second rule, which is always the allow empty rule.
423
     *
424
     * @return Rule\NotEmpty
425
     */
426 4
    protected function getNotEmptyRule()
427
    {
428 4
        return $this->rules[1];
429
    }
430
}
431