GitHub Access Token became invalid

It seems like the GitHub access token used for retrieving details about this repository from GitHub became invalid. This might prevent certain types of inspections from being run (in particular, everything related to pull requests).
Please ask an admin of your repository to re-new the access token on this website.
Completed
Push — master ( e21493...734bc2 )
by Rick
03:13 queued 14s
created

Chain::string()   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 1
Metric Value
c 1
b 0
f 1
dl 0
loc 4
ccs 2
cts 2
cp 1
rs 10
cc 1
eloc 2
nc 1
nop 0
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-2016 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 201
    public function __construct($key, $name, $required, $allowEmpty)
59
    {
60 201
        $this->key = $key;
61 201
        $this->name = $name;
62
63 201
        $this->addRule(new Rule\Required($required));
64 201
        $this->addRule(new Rule\NotEmpty($allowEmpty));
65 201
    }
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 valid credit card number.
136
     * @return $this
137
     */
138 15
    public function creditCard()
139
    {
140 15
        return $this->addRule(new Rule\CreditCard());
141
    }
142
143
    /**
144
     * Validates that the value is a date. If format is passed, it *must* be in that format.
145
     *
146
     * @param string|null $format
147
     * @return $this
148
     */
149 8
    public function datetime($format = null)
150
    {
151 8
        return $this->addRule(new Rule\Datetime($format));
152
    }
153
154
    /**
155
     * Validates that all characters of the value are decimal digits.
156
     *
157
     * @return $this
158
     */
159 4
    public function digits()
160
    {
161 4
        return $this->addRule(new Rule\Digits());
162
    }
163
164
    /**
165
     * Validates a value to be a nested array, which can then be validated using a new Validator instance.
166
     *
167
     * @param callable $callback
168
     * @return $this
169
     */
170 5
    public function each(callable $callback)
171
    {
172 5
        return $this->addRule(new Rule\Each($callback));
173
    }
174
175
    /**
176
     * Validates that the value is a valid email address (format only).
177
     * @return $this
178
     */
179 6
    public function email()
180
    {
181 6
        return $this->addRule(new Rule\Email());
182
    }
183
184
    /**
185
     * Validates that the value is equal to $value.
186
     *
187
     * @param string $value
188
     * @return $this
189
     */
190 2
    public function equals($value)
191
    {
192 2
        return $this->addRule(new Rule\Equal($value));
193
    }
194
195
    /**
196
     * Validates that the value is greater than $value.
197
     *
198
     * @param int $value
199
     * @return $this
200
     */
201 3
    public function greaterThan($value)
202
    {
203 3
        return $this->addRule(new Rule\GreaterThan($value));
204
    }
205
206
    /**
207
     * Validates that the value is in the array with optional "loose" checking.
208
     *
209
     * @param array $array
210
     * @param bool $strict
211
     * @return $this
212
     */
213 4
    public function inArray(array $array, $strict = true)
214
    {
215 4
        return $this->addRule(new Rule\InArray($array, $strict));
216
    }
217
218
    /**
219
     * Validates the value represents a valid integer
220
     *
221
     * @param bool $strict
222
     * @return $this
223
     * @see \Particle\Validator\Rule\Integer
224
     */
225 18
    public function integer($strict = false)
226
    {
227 18
        return $this->addRule(new Rule\Integer($strict));
228
    }
229
230
    /**
231
     * Validates the value is an array
232
     *
233
     * @return $this
234
     * @see \Particle\Validator\Rule\IsArray
235
     */
236 7
    public function isArray()
237
    {
238 7
        return $this->addRule(new Rule\IsArray());
239
    }
240
241
    /**
242
     * Validates that the value represents a valid JSON string
243
     *
244
     * @return $this
245
     * @see \Particle\Validator\Rule\Json
246
     */
247 11
    public function json()
248
    {
249 11
        return $this->addRule(new Rule\Json());
250
    }
251
252
    /**
253
     * Validate the value to be of precisely length $length.
254
     *
255
     * @param int $length
256
     * @return $this
257
     */
258 13
    public function length($length)
259
    {
260 13
        return $this->addRule(new Rule\Length($length));
261
    }
262
263
    /**
264
     * Validates that the length of the value is between $min and $max.
265
     *
266
     * If $max is null, it has no upper limit. The default is inclusive.
267
     *
268
     * @param int $min
269
     * @param int|null $max
270
     * @return $this
271
     */
272 7
    public function lengthBetween($min, $max)
273
    {
274 7
        return $this->addRule(new Rule\LengthBetween($min, $max));
275
    }
276
277
    /**
278
     * Validates that the value is less than $value.
279
     *
280
     * @param int $value
281
     * @return $this
282
     */
283 3
    public function lessThan($value)
284
    {
285 3
        return $this->addRule(new Rule\LessThan($value));
286
    }
287
288
    /**
289
     * Mount a rule object onto this chain.
290
     *
291
     * @param Rule $rule
292
     * @return $this
293
     */
294 1
    public function mount(Rule $rule)
295
    {
296 1
        return $this->addRule($rule);
297
    }
298
299
    /**
300
     * Validates that the value is either a integer or a float.
301
     *
302
     * @return $this
303
     */
304 11
    public function numeric()
305
    {
306 11
        return $this->addRule(new Rule\Numeric());
307
    }
308
309
    /**
310
     * Validates that the value is a valid phone number for $countryCode.
311
     *
312
     * @param string $countryCode
313
     * @see \Particle\Validator\Rule\Phone
314
     * @return $this
315
     */
316 13
    public function phone($countryCode)
317
    {
318 13
        return $this->addRule(new Rule\Phone($countryCode));
319
    }
320
321
    /**
322
     * Validates that the value matches the regular expression $regex.
323
     *
324
     * @param string $regex
325
     * @return $this
326
     */
327 2
    public function regex($regex)
328
    {
329 2
        return $this->addRule(new Rule\Regex($regex));
330
    }
331
332
    /**
333
     * Validates that the value represents a string.
334
     *
335
     * @return $this
336
     */
337 5
    public function string()
338
    {
339 5
        return $this->addRule(new Rule\IsString());
340
    }
341
342
    /**
343
     * Validates that the value is a valid URL. The schemes array is to selectively whitelist URL schemes.
344
     *
345
     * @param array $schemes
346
     * @return $this
347
     */
348 7
    public function url(array $schemes = [])
349
    {
350 7
        return $this->addRule(new Rule\Url($schemes));
351
    }
352
353
    /**
354
     * Validates that the value is a valid UUID
355
     *
356
     * @param int $version
357
     * @return $this
358
     */
359 12
    public function uuid($version = Rule\Uuid::UUID_V4)
360
    {
361 12
        return $this->addRule(new Rule\Uuid($version));
362
    }
363
364
    /**
365
     * Set a callable or boolean value which may be used to alter the required requirement on validation time.
366
     *
367
     * This may be incredibly helpful when doing conditional validation.
368
     *
369
     * @param callable|bool $required
370
     * @return $this
371
     */
372 5
    public function required($required)
373
    {
374 5
        $this->getRequiredRule()->setRequired($required);
375 5
        return $this;
376
    }
377
378
    /**
379
     * Set a callable or boolean value which may be used to alter the allow empty requirement on validation time.
380
     *
381
     * This may be incredibly helpful when doing conditional validation.
382
     *
383
     * @param callable|bool $allowEmpty
384
     * @return $this
385
     */
386 11
    public function allowEmpty($allowEmpty)
387
    {
388 11
        $this->getNotEmptyRule()->setAllowEmpty($allowEmpty);
389 11
        return $this;
390
    }
391
392
    /**
393
     * Attach a representation of this Chain to the Output\Structure $structure.
394
     *
395
     * @internal
396
     * @param Structure $structure
397
     * @param MessageStack $messageStack
398
     * @return Structure
399
     */
400 2
    public function output(Structure $structure, MessageStack $messageStack)
401
    {
402 2
        $subject = new Subject($this->key, $this->name);
403
404 2
        foreach ($this->rules as $rule) {
405 2
            $rule->output($subject, $messageStack);
406 2
        }
407
408 2
        $structure->addSubject($subject);
409
410 2
        return $structure;
411
    }
412
413
    /**
414
     * Validates the values in the $values array and appends messages to $messageStack. Returns the result as a bool.
415
     *
416
     * @param MessageStack $messageStack
417
     * @param Container $input
418
     * @param Container $output
419
     * @return bool
420
     */
421 198
    public function validate(MessageStack $messageStack, Container $input, Container $output)
422
    {
423 198
        $valid = true;
424 198
        foreach ($this->rules as $rule) {
425 198
            $rule->setMessageStack($messageStack);
426 198
            $rule->setParameters($this->key, $this->name);
427
428 198
            $valid = $rule->isValid($this->key, $input) && $valid;
429
430 198
            if ($rule->shouldBreakChain()) {
431 17
                break;
432
            }
433 198
        }
434
435 198
        if ($valid && $input->has($this->key)) {
436 103
            $output->set($this->key, $input->get($this->key));
437 103
        }
438 198
        return $valid;
439
    }
440
441
    /**
442
     * Shortcut method for storing a rule on this chain, and returning the chain.
443
     *
444
     * @param Rule $rule
445
     * @return $this
446
     */
447 201
    protected function addRule(Rule $rule)
448
    {
449 201
        $this->rules[] = $rule;
450
451 201
        return $this;
452
    }
453
454
    /**
455
     * Returns the first rule, which is always the required rule.
456
     *
457
     * @return Rule\Required
458
     */
459 5
    protected function getRequiredRule()
460
    {
461 5
        return $this->rules[0];
462
    }
463
464
    /**
465
     * Returns the second rule, which is always the allow empty rule.
466
     *
467
     * @return Rule\NotEmpty
468
     */
469 11
    protected function getNotEmptyRule()
470
    {
471 11
        return $this->rules[1];
472
    }
473
}
474