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 ( 8e9c3c...46228f )
by Rick
07:43 queued 05:16
created

Chain::required()   A

Complexity

Conditions 1
Paths 1

Size

Total Lines 5
Code Lines 3

Duplication

Lines 0
Ratio 0 %

Code Coverage

Tests 3
CRAP Score 1

Importance

Changes 3
Bugs 0 Features 0
Metric Value
c 3
b 0
f 0
dl 0
loc 5
ccs 3
cts 3
cp 1
rs 9.4285
cc 1
eloc 3
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