Namespaces

Classes

Interfaces

1: <?php
2:
3: /*
4: * This file is part of the webmozart/assert package.
5: *
6: * (c) Bernhard Schussek <bschussek@gmail.com>
7: *
8: * For the full copyright and license information, please view the LICENSE
9: * file that was distributed with this source code.
10: */
11:
12: namespace Webmozart\Assert;
13:
14: use ArrayAccess;
15: use BadMethodCallException;
16: use Closure;
17: use Countable;
18: use DateTime;
19: use DateTimeImmutable;
20: use Exception;
21: use InvalidArgumentException;
22: use ResourceBundle;
23: use SimpleXMLElement;
24: use Throwable;
25: use Traversable;
26:
27: /**
28: * Efficient assertions to validate the input/output of your methods.
29: *
30: * @mixin Mixin
31: *
32: * @since 1.0
33: *
34: * @author Bernhard Schussek <bschussek@gmail.com>
35: */
36: class Assert
37: {
38: /**
39: * @psalm-pure
40: * @psalm-assert string $value
41: *
42: * @param mixed $value
43: * @param string $message
44: *
45: * @throws InvalidArgumentException
46: */
47: public static function string($value, $message = '')
48: {
49: if (!\is_string($value)) {
50: static::reportInvalidArgument(\sprintf(
51: $message ?: 'Expected a string. Got: %s',
52: static::typeToString($value)
53: ));
54: }
55: }
56:
57: /**
58: * @psalm-pure
59: * @psalm-assert non-empty-string $value
60: *
61: * @param mixed $value
62: * @param string $message
63: *
64: * @throws InvalidArgumentException
65: */
66: public static function stringNotEmpty($value, $message = '')
67: {
68: static::string($value, $message);
69: static::notEq($value, '', $message);
70: }
71:
72: /**
73: * @psalm-pure
74: * @psalm-assert int $value
75: *
76: * @param mixed $value
77: * @param string $message
78: *
79: * @throws InvalidArgumentException
80: */
81: public static function integer($value, $message = '')
82: {
83: if (!\is_int($value)) {
84: static::reportInvalidArgument(\sprintf(
85: $message ?: 'Expected an integer. Got: %s',
86: static::typeToString($value)
87: ));
88: }
89: }
90:
91: /**
92: * @psalm-pure
93: * @psalm-assert numeric $value
94: *
95: * @param mixed $value
96: * @param string $message
97: *
98: * @throws InvalidArgumentException
99: */
100: public static function integerish($value, $message = '')
101: {
102: if (!\is_numeric($value) || $value != (int) $value) {
103: static::reportInvalidArgument(\sprintf(
104: $message ?: 'Expected an integerish value. Got: %s',
105: static::typeToString($value)
106: ));
107: }
108: }
109:
110: /**
111: * @psalm-pure
112: * @psalm-assert float $value
113: *
114: * @param mixed $value
115: * @param string $message
116: *
117: * @throws InvalidArgumentException
118: */
119: public static function float($value, $message = '')
120: {
121: if (!\is_float($value)) {
122: static::reportInvalidArgument(\sprintf(
123: $message ?: 'Expected a float. Got: %s',
124: static::typeToString($value)
125: ));
126: }
127: }
128:
129: /**
130: * @psalm-pure
131: * @psalm-assert numeric $value
132: *
133: * @param mixed $value
134: * @param string $message
135: *
136: * @throws InvalidArgumentException
137: */
138: public static function numeric($value, $message = '')
139: {
140: if (!\is_numeric($value)) {
141: static::reportInvalidArgument(\sprintf(
142: $message ?: 'Expected a numeric. Got: %s',
143: static::typeToString($value)
144: ));
145: }
146: }
147:
148: /**
149: * @psalm-pure
150: * @psalm-assert int $value
151: *
152: * @param mixed $value
153: * @param string $message
154: *
155: * @throws InvalidArgumentException
156: */
157: public static function natural($value, $message = '')
158: {
159: if (!\is_int($value) || $value < 0) {
160: static::reportInvalidArgument(\sprintf(
161: $message ?: 'Expected a non-negative integer. Got: %s',
162: static::valueToString($value)
163: ));
164: }
165: }
166:
167: /**
168: * @psalm-pure
169: * @psalm-assert bool $value
170: *
171: * @param mixed $value
172: * @param string $message
173: *
174: * @throws InvalidArgumentException
175: */
176: public static function boolean($value, $message = '')
177: {
178: if (!\is_bool($value)) {
179: static::reportInvalidArgument(\sprintf(
180: $message ?: 'Expected a boolean. Got: %s',
181: static::typeToString($value)
182: ));
183: }
184: }
185:
186: /**
187: * @psalm-pure
188: * @psalm-assert scalar $value
189: *
190: * @param mixed $value
191: * @param string $message
192: *
193: * @throws InvalidArgumentException
194: */
195: public static function scalar($value, $message = '')
196: {
197: if (!\is_scalar($value)) {
198: static::reportInvalidArgument(\sprintf(
199: $message ?: 'Expected a scalar. Got: %s',
200: static::typeToString($value)
201: ));
202: }
203: }
204:
205: /**
206: * @psalm-pure
207: * @psalm-assert object $value
208: *
209: * @param mixed $value
210: * @param string $message
211: *
212: * @throws InvalidArgumentException
213: */
214: public static function object($value, $message = '')
215: {
216: if (!\is_object($value)) {
217: static::reportInvalidArgument(\sprintf(
218: $message ?: 'Expected an object. Got: %s',
219: static::typeToString($value)
220: ));
221: }
222: }
223:
224: /**
225: * @psalm-pure
226: * @psalm-assert resource $value
227: *
228: * @param mixed $value
229: * @param string|null $type type of resource this should be. @see https://www.php.net/manual/en/function.get-resource-type.php
230: * @param string $message
231: *
232: * @throws InvalidArgumentException
233: */
234: public static function resource($value, $type = null, $message = '')
235: {
236: if (!\is_resource($value)) {
237: static::reportInvalidArgument(\sprintf(
238: $message ?: 'Expected a resource. Got: %s',
239: static::typeToString($value)
240: ));
241: }
242:
243: if ($type && $type !== \get_resource_type($value)) {
244: static::reportInvalidArgument(\sprintf(
245: $message ?: 'Expected a resource of type %2$s. Got: %s',
246: static::typeToString($value),
247: $type
248: ));
249: }
250: }
251:
252: /**
253: * @psalm-pure
254: * @psalm-assert callable $value
255: *
256: * @param mixed $value
257: * @param string $message
258: *
259: * @throws InvalidArgumentException
260: */
261: public static function isCallable($value, $message = '')
262: {
263: if (!\is_callable($value)) {
264: static::reportInvalidArgument(\sprintf(
265: $message ?: 'Expected a callable. Got: %s',
266: static::typeToString($value)
267: ));
268: }
269: }
270:
271: /**
272: * @psalm-pure
273: * @psalm-assert array $value
274: *
275: * @param mixed $value
276: * @param string $message
277: *
278: * @throws InvalidArgumentException
279: */
280: public static function isArray($value, $message = '')
281: {
282: if (!\is_array($value)) {
283: static::reportInvalidArgument(\sprintf(
284: $message ?: 'Expected an array. Got: %s',
285: static::typeToString($value)
286: ));
287: }
288: }
289:
290: /**
291: * @psalm-pure
292: * @psalm-assert iterable $value
293: *
294: * @deprecated use "isIterable" or "isInstanceOf" instead
295: *
296: * @param mixed $value
297: * @param string $message
298: *
299: * @throws InvalidArgumentException
300: */
301: public static function isTraversable($value, $message = '')
302: {
303: @\trigger_error(
304: \sprintf(
305: 'The "%s" assertion is deprecated. You should stop using it, as it will soon be removed in 2.0 version. Use "isIterable" or "isInstanceOf" instead.',
306: __METHOD__
307: ),
308: \E_USER_DEPRECATED
309: );
310:
311: if (!\is_array($value) && !($value instanceof Traversable)) {
312: static::reportInvalidArgument(\sprintf(
313: $message ?: 'Expected a traversable. Got: %s',
314: static::typeToString($value)
315: ));
316: }
317: }
318:
319: /**
320: * @psalm-pure
321: * @psalm-assert array|ArrayAccess $value
322: *
323: * @param mixed $value
324: * @param string $message
325: *
326: * @throws InvalidArgumentException
327: */
328: public static function isArrayAccessible($value, $message = '')
329: {
330: if (!\is_array($value) && !($value instanceof ArrayAccess)) {
331: static::reportInvalidArgument(\sprintf(
332: $message ?: 'Expected an array accessible. Got: %s',
333: static::typeToString($value)
334: ));
335: }
336: }
337:
338: /**
339: * @psalm-pure
340: * @psalm-assert countable $value
341: *
342: * @param mixed $value
343: * @param string $message
344: *
345: * @throws InvalidArgumentException
346: */
347: public static function isCountable($value, $message = '')
348: {
349: if (
350: !\is_array($value)
351: && !($value instanceof Countable)
352: && !($value instanceof ResourceBundle)
353: && !($value instanceof SimpleXMLElement)
354: ) {
355: static::reportInvalidArgument(\sprintf(
356: $message ?: 'Expected a countable. Got: %s',
357: static::typeToString($value)
358: ));
359: }
360: }
361:
362: /**
363: * @psalm-pure
364: * @psalm-assert iterable $value
365: *
366: * @param mixed $value
367: * @param string $message
368: *
369: * @throws InvalidArgumentException
370: */
371: public static function isIterable($value, $message = '')
372: {
373: if (!\is_array($value) && !($value instanceof Traversable)) {
374: static::reportInvalidArgument(\sprintf(
375: $message ?: 'Expected an iterable. Got: %s',
376: static::typeToString($value)
377: ));
378: }
379: }
380:
381: /**
382: * @psalm-pure
383: * @psalm-template ExpectedType of object
384: * @psalm-param class-string<ExpectedType> $class
385: * @psalm-assert ExpectedType $value
386: *
387: * @param mixed $value
388: * @param string|object $class
389: * @param string $message
390: *
391: * @throws InvalidArgumentException
392: */
393: public static function isInstanceOf($value, $class, $message = '')
394: {
395: if (!($value instanceof $class)) {
396: static::reportInvalidArgument(\sprintf(
397: $message ?: 'Expected an instance of %2$s. Got: %s',
398: static::typeToString($value),
399: $class
400: ));
401: }
402: }
403:
404: /**
405: * @psalm-pure
406: * @psalm-template ExpectedType of object
407: * @psalm-param class-string<ExpectedType> $class
408: * @psalm-assert !ExpectedType $value
409: *
410: * @param mixed $value
411: * @param string|object $class
412: * @param string $message
413: *
414: * @throws InvalidArgumentException
415: */
416: public static function notInstanceOf($value, $class, $message = '')
417: {
418: if ($value instanceof $class) {
419: static::reportInvalidArgument(\sprintf(
420: $message ?: 'Expected an instance other than %2$s. Got: %s',
421: static::typeToString($value),
422: $class
423: ));
424: }
425: }
426:
427: /**
428: * @psalm-pure
429: * @psalm-param array<class-string> $classes
430: *
431: * @param mixed $value
432: * @param array<object|string> $classes
433: * @param string $message
434: *
435: * @throws InvalidArgumentException
436: */
437: public static function isInstanceOfAny($value, array $classes, $message = '')
438: {
439: foreach ($classes as $class) {
440: if ($value instanceof $class) {
441: return;
442: }
443: }
444:
445: static::reportInvalidArgument(\sprintf(
446: $message ?: 'Expected an instance of any of %2$s. Got: %s',
447: static::typeToString($value),
448: \implode(', ', \array_map(array('static', 'valueToString'), $classes))
449: ));
450: }
451:
452: /**
453: * @psalm-pure
454: * @psalm-template ExpectedType of object
455: * @psalm-param class-string<ExpectedType> $class
456: * @psalm-assert ExpectedType|class-string<ExpectedType> $value
457: *
458: * @param object|string $value
459: * @param string $class
460: * @param string $message
461: *
462: * @throws InvalidArgumentException
463: */
464: public static function isAOf($value, $class, $message = '')
465: {
466: static::string($class, 'Expected class as a string. Got: %s');
467:
468: if (!\is_a($value, $class, \is_string($value))) {
469: static::reportInvalidArgument(sprintf(
470: $message ?: 'Expected an instance of this class or to this class among his parents %2$s. Got: %s',
471: static::typeToString($value),
472: $class
473: ));
474: }
475: }
476:
477: /**
478: * @psalm-pure
479: * @psalm-template UnexpectedType of object
480: * @psalm-param class-string<UnexpectedType> $class
481: * @psalm-assert !UnexpectedType $value
482: * @psalm-assert !class-string<UnexpectedType> $value
483: *
484: * @param object|string $value
485: * @param string $class
486: * @param string $message
487: *
488: * @throws InvalidArgumentException
489: */
490: public static function isNotA($value, $class, $message = '')
491: {
492: static::string($class, 'Expected class as a string. Got: %s');
493:
494: if (\is_a($value, $class, \is_string($value))) {
495: static::reportInvalidArgument(sprintf(
496: $message ?: 'Expected an instance of this class or to this class among his parents other than %2$s. Got: %s',
497: static::typeToString($value),
498: $class
499: ));
500: }
501: }
502:
503: /**
504: * @psalm-pure
505: * @psalm-param array<class-string> $classes
506: *
507: * @param object|string $value
508: * @param string[] $classes
509: * @param string $message
510: *
511: * @throws InvalidArgumentException
512: */
513: public static function isAnyOf($value, array $classes, $message = '')
514: {
515: foreach ($classes as $class) {
516: static::string($class, 'Expected class as a string. Got: %s');
517:
518: if (\is_a($value, $class, \is_string($value))) {
519: return;
520: }
521: }
522:
523: static::reportInvalidArgument(sprintf(
524: $message ?: 'Expected an any of instance of this class or to this class among his parents other than %2$s. Got: %s',
525: static::typeToString($value),
526: \implode(', ', \array_map(array('static', 'valueToString'), $classes))
527: ));
528: }
529:
530: /**
531: * @psalm-pure
532: * @psalm-assert empty $value
533: *
534: * @param mixed $value
535: * @param string $message
536: *
537: * @throws InvalidArgumentException
538: */
539: public static function isEmpty($value, $message = '')
540: {
541: if (!empty($value)) {
542: static::reportInvalidArgument(\sprintf(
543: $message ?: 'Expected an empty value. Got: %s',
544: static::valueToString($value)
545: ));
546: }
547: }
548:
549: /**
550: * @psalm-pure
551: * @psalm-assert !empty $value
552: *
553: * @param mixed $value
554: * @param string $message
555: *
556: * @throws InvalidArgumentException
557: */
558: public static function notEmpty($value, $message = '')
559: {
560: if (empty($value)) {
561: static::reportInvalidArgument(\sprintf(
562: $message ?: 'Expected a non-empty value. Got: %s',
563: static::valueToString($value)
564: ));
565: }
566: }
567:
568: /**
569: * @psalm-pure
570: * @psalm-assert null $value
571: *
572: * @param mixed $value
573: * @param string $message
574: *
575: * @throws InvalidArgumentException
576: */
577: public static function null($value, $message = '')
578: {
579: if (null !== $value) {
580: static::reportInvalidArgument(\sprintf(
581: $message ?: 'Expected null. Got: %s',
582: static::valueToString($value)
583: ));
584: }
585: }
586:
587: /**
588: * @psalm-pure
589: * @psalm-assert !null $value
590: *
591: * @param mixed $value
592: * @param string $message
593: *
594: * @throws InvalidArgumentException
595: */
596: public static function notNull($value, $message = '')
597: {
598: if (null === $value) {
599: static::reportInvalidArgument(
600: $message ?: 'Expected a value other than null.'
601: );
602: }
603: }
604:
605: /**
606: * @psalm-pure
607: * @psalm-assert true $value
608: *
609: * @param mixed $value
610: * @param string $message
611: *
612: * @throws InvalidArgumentException
613: */
614: public static function true($value, $message = '')
615: {
616: if (true !== $value) {
617: static::reportInvalidArgument(\sprintf(
618: $message ?: 'Expected a value to be true. Got: %s',
619: static::valueToString($value)
620: ));
621: }
622: }
623:
624: /**
625: * @psalm-pure
626: * @psalm-assert false $value
627: *
628: * @param mixed $value
629: * @param string $message
630: *
631: * @throws InvalidArgumentException
632: */
633: public static function false($value, $message = '')
634: {
635: if (false !== $value) {
636: static::reportInvalidArgument(\sprintf(
637: $message ?: 'Expected a value to be false. Got: %s',
638: static::valueToString($value)
639: ));
640: }
641: }
642:
643: /**
644: * @psalm-pure
645: * @psalm-assert !false $value
646: *
647: * @param mixed $value
648: * @param string $message
649: *
650: * @throws InvalidArgumentException
651: */
652: public static function notFalse($value, $message = '')
653: {
654: if (false === $value) {
655: static::reportInvalidArgument(
656: $message ?: 'Expected a value other than false.'
657: );
658: }
659: }
660:
661: /**
662: * @param mixed $value
663: * @param string $message
664: *
665: * @throws InvalidArgumentException
666: */
667: public static function ip($value, $message = '')
668: {
669: if (false === \filter_var($value, \FILTER_VALIDATE_IP)) {
670: static::reportInvalidArgument(\sprintf(
671: $message ?: 'Expected a value to be an IP. Got: %s',
672: static::valueToString($value)
673: ));
674: }
675: }
676:
677: /**
678: * @param mixed $value
679: * @param string $message
680: *
681: * @throws InvalidArgumentException
682: */
683: public static function ipv4($value, $message = '')
684: {
685: if (false === \filter_var($value, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV4)) {
686: static::reportInvalidArgument(\sprintf(
687: $message ?: 'Expected a value to be an IPv4. Got: %s',
688: static::valueToString($value)
689: ));
690: }
691: }
692:
693: /**
694: * @param mixed $value
695: * @param string $message
696: *
697: * @throws InvalidArgumentException
698: */
699: public static function ipv6($value, $message = '')
700: {
701: if (false === \filter_var($value, \FILTER_VALIDATE_IP, \FILTER_FLAG_IPV6)) {
702: static::reportInvalidArgument(\sprintf(
703: $message ?: 'Expected a value to be an IPv6. Got: %s',
704: static::valueToString($value)
705: ));
706: }
707: }
708:
709: /**
710: * @param mixed $value
711: * @param string $message
712: *
713: * @throws InvalidArgumentException
714: */
715: public static function email($value, $message = '')
716: {
717: if (false === \filter_var($value, FILTER_VALIDATE_EMAIL)) {
718: static::reportInvalidArgument(\sprintf(
719: $message ?: 'Expected a value to be a valid e-mail address. Got: %s',
720: static::valueToString($value)
721: ));
722: }
723: }
724:
725: /**
726: * Does non strict comparisons on the items, so ['3', 3] will not pass the assertion.
727: *
728: * @param array $values
729: * @param string $message
730: *
731: * @throws InvalidArgumentException
732: */
733: public static function uniqueValues(array $values, $message = '')
734: {
735: $allValues = \count($values);
736: $uniqueValues = \count(\array_unique($values));
737:
738: if ($allValues !== $uniqueValues) {
739: $difference = $allValues - $uniqueValues;
740:
741: static::reportInvalidArgument(\sprintf(
742: $message ?: 'Expected an array of unique values, but %s of them %s duplicated',
743: $difference,
744: (1 === $difference ? 'is' : 'are')
745: ));
746: }
747: }
748:
749: /**
750: * @param mixed $value
751: * @param mixed $expect
752: * @param string $message
753: *
754: * @throws InvalidArgumentException
755: */
756: public static function eq($value, $expect, $message = '')
757: {
758: if ($expect != $value) {
759: static::reportInvalidArgument(\sprintf(
760: $message ?: 'Expected a value equal to %2$s. Got: %s',
761: static::valueToString($value),
762: static::valueToString($expect)
763: ));
764: }
765: }
766:
767: /**
768: * @param mixed $value
769: * @param mixed $expect
770: * @param string $message
771: *
772: * @throws InvalidArgumentException
773: */
774: public static function notEq($value, $expect, $message = '')
775: {
776: if ($expect == $value) {
777: static::reportInvalidArgument(\sprintf(
778: $message ?: 'Expected a different value than %s.',
779: static::valueToString($expect)
780: ));
781: }
782: }
783:
784: /**
785: * @psalm-pure
786: *
787: * @param mixed $value
788: * @param mixed $expect
789: * @param string $message
790: *
791: * @throws InvalidArgumentException
792: */
793: public static function same($value, $expect, $message = '')
794: {
795: if ($expect !== $value) {
796: static::reportInvalidArgument(\sprintf(
797: $message ?: 'Expected a value identical to %2$s. Got: %s',
798: static::valueToString($value),
799: static::valueToString($expect)
800: ));
801: }
802: }
803:
804: /**
805: * @psalm-pure
806: *
807: * @param mixed $value
808: * @param mixed $expect
809: * @param string $message
810: *
811: * @throws InvalidArgumentException
812: */
813: public static function notSame($value, $expect, $message = '')
814: {
815: if ($expect === $value) {
816: static::reportInvalidArgument(\sprintf(
817: $message ?: 'Expected a value not identical to %s.',
818: static::valueToString($expect)
819: ));
820: }
821: }
822:
823: /**
824: * @psalm-pure
825: *
826: * @param mixed $value
827: * @param mixed $limit
828: * @param string $message
829: *
830: * @throws InvalidArgumentException
831: */
832: public static function greaterThan($value, $limit, $message = '')
833: {
834: if ($value <= $limit) {
835: static::reportInvalidArgument(\sprintf(
836: $message ?: 'Expected a value greater than %2$s. Got: %s',
837: static::valueToString($value),
838: static::valueToString($limit)
839: ));
840: }
841: }
842:
843: /**
844: * @psalm-pure
845: *
846: * @param mixed $value
847: * @param mixed $limit
848: * @param string $message
849: *
850: * @throws InvalidArgumentException
851: */
852: public static function greaterThanEq($value, $limit, $message = '')
853: {
854: if ($value < $limit) {
855: static::reportInvalidArgument(\sprintf(
856: $message ?: 'Expected a value greater than or equal to %2$s. Got: %s',
857: static::valueToString($value),
858: static::valueToString($limit)
859: ));
860: }
861: }
862:
863: /**
864: * @psalm-pure
865: *
866: * @param mixed $value
867: * @param mixed $limit
868: * @param string $message
869: *
870: * @throws InvalidArgumentException
871: */
872: public static function lessThan($value, $limit, $message = '')
873: {
874: if ($value >= $limit) {
875: static::reportInvalidArgument(\sprintf(
876: $message ?: 'Expected a value less than %2$s. Got: %s',
877: static::valueToString($value),
878: static::valueToString($limit)
879: ));
880: }
881: }
882:
883: /**
884: * @psalm-pure
885: *
886: * @param mixed $value
887: * @param mixed $limit
888: * @param string $message
889: *
890: * @throws InvalidArgumentException
891: */
892: public static function lessThanEq($value, $limit, $message = '')
893: {
894: if ($value > $limit) {
895: static::reportInvalidArgument(\sprintf(
896: $message ?: 'Expected a value less than or equal to %2$s. Got: %s',
897: static::valueToString($value),
898: static::valueToString($limit)
899: ));
900: }
901: }
902:
903: /**
904: * Inclusive range, so Assert::(3, 3, 5) passes.
905: *
906: * @psalm-pure
907: *
908: * @param mixed $value
909: * @param mixed $min
910: * @param mixed $max
911: * @param string $message
912: *
913: * @throws InvalidArgumentException
914: */
915: public static function range($value, $min, $max, $message = '')
916: {
917: if ($value < $min || $value > $max) {
918: static::reportInvalidArgument(\sprintf(
919: $message ?: 'Expected a value between %2$s and %3$s. Got: %s',
920: static::valueToString($value),
921: static::valueToString($min),
922: static::valueToString($max)
923: ));
924: }
925: }
926:
927: /**
928: * A more human-readable alias of Assert::inArray().
929: *
930: * @psalm-pure
931: *
932: * @param mixed $value
933: * @param array $values
934: * @param string $message
935: *
936: * @throws InvalidArgumentException
937: */
938: public static function oneOf($value, array $values, $message = '')
939: {
940: static::inArray($value, $values, $message);
941: }
942:
943: /**
944: * Does strict comparison, so Assert::inArray(3, ['3']) does not pass the assertion.
945: *
946: * @psalm-pure
947: *
948: * @param mixed $value
949: * @param array $values
950: * @param string $message
951: *
952: * @throws InvalidArgumentException
953: */
954: public static function inArray($value, array $values, $message = '')
955: {
956: if (!\in_array($value, $values, true)) {
957: static::reportInvalidArgument(\sprintf(
958: $message ?: 'Expected one of: %2$s. Got: %s',
959: static::valueToString($value),
960: \implode(', ', \array_map(array('static', 'valueToString'), $values))
961: ));
962: }
963: }
964:
965: /**
966: * @psalm-pure
967: *
968: * @param string $value
969: * @param string $subString
970: * @param string $message
971: *
972: * @throws InvalidArgumentException
973: */
974: public static function contains($value, $subString, $message = '')
975: {
976: if (false === \strpos($value, $subString)) {
977: static::reportInvalidArgument(\sprintf(
978: $message ?: 'Expected a value to contain %2$s. Got: %s',
979: static::valueToString($value),
980: static::valueToString($subString)
981: ));
982: }
983: }
984:
985: /**
986: * @psalm-pure
987: *
988: * @param string $value
989: * @param string $subString
990: * @param string $message
991: *
992: * @throws InvalidArgumentException
993: */
994: public static function notContains($value, $subString, $message = '')
995: {
996: if (false !== \strpos($value, $subString)) {
997: static::reportInvalidArgument(\sprintf(
998: $message ?: '%2$s was not expected to be contained in a value. Got: %s',
999: static::valueToString($value),
1000: static::valueToString($subString)
1001: ));
1002: }
1003: }
1004:
1005: /**
1006: * @psalm-pure
1007: *
1008: * @param string $value
1009: * @param string $message
1010: *
1011: * @throws InvalidArgumentException
1012: */
1013: public static function notWhitespaceOnly($value, $message = '')
1014: {
1015: if (\preg_match('/^\s*$/', $value)) {
1016: static::reportInvalidArgument(\sprintf(
1017: $message ?: 'Expected a non-whitespace string. Got: %s',
1018: static::valueToString($value)
1019: ));
1020: }
1021: }
1022:
1023: /**
1024: * @psalm-pure
1025: *
1026: * @param string $value
1027: * @param string $prefix
1028: * @param string $message
1029: *
1030: * @throws InvalidArgumentException
1031: */
1032: public static function startsWith($value, $prefix, $message = '')
1033: {
1034: if (0 !== \strpos($value, $prefix)) {
1035: static::reportInvalidArgument(\sprintf(
1036: $message ?: 'Expected a value to start with %2$s. Got: %s',
1037: static::valueToString($value),
1038: static::valueToString($prefix)
1039: ));
1040: }
1041: }
1042:
1043: /**
1044: * @psalm-pure
1045: *
1046: * @param string $value
1047: * @param string $prefix
1048: * @param string $message
1049: *
1050: * @throws InvalidArgumentException
1051: */
1052: public static function notStartsWith($value, $prefix, $message = '')
1053: {
1054: if (0 === \strpos($value, $prefix)) {
1055: static::reportInvalidArgument(\sprintf(
1056: $message ?: 'Expected a value not to start with %2$s. Got: %s',
1057: static::valueToString($value),
1058: static::valueToString($prefix)
1059: ));
1060: }
1061: }
1062:
1063: /**
1064: * @psalm-pure
1065: *
1066: * @param mixed $value
1067: * @param string $message
1068: *
1069: * @throws InvalidArgumentException
1070: */
1071: public static function startsWithLetter($value, $message = '')
1072: {
1073: static::string($value);
1074:
1075: $valid = isset($value[0]);
1076:
1077: if ($valid) {
1078: $locale = \setlocale(LC_CTYPE, 0);
1079: \setlocale(LC_CTYPE, 'C');
1080: $valid = \ctype_alpha($value[0]);
1081: \setlocale(LC_CTYPE, $locale);
1082: }
1083:
1084: if (!$valid) {
1085: static::reportInvalidArgument(\sprintf(
1086: $message ?: 'Expected a value to start with a letter. Got: %s',
1087: static::valueToString($value)
1088: ));
1089: }
1090: }
1091:
1092: /**
1093: * @psalm-pure
1094: *
1095: * @param string $value
1096: * @param string $suffix
1097: * @param string $message
1098: *
1099: * @throws InvalidArgumentException
1100: */
1101: public static function endsWith($value, $suffix, $message = '')
1102: {
1103: if ($suffix !== \substr($value, -\strlen($suffix))) {
1104: static::reportInvalidArgument(\sprintf(
1105: $message ?: 'Expected a value to end with %2$s. Got: %s',
1106: static::valueToString($value),
1107: static::valueToString($suffix)
1108: ));
1109: }
1110: }
1111:
1112: /**
1113: * @psalm-pure
1114: *
1115: * @param string $value
1116: * @param string $suffix
1117: * @param string $message
1118: *
1119: * @throws InvalidArgumentException
1120: */
1121: public static function notEndsWith($value, $suffix, $message = '')
1122: {
1123: if ($suffix === \substr($value, -\strlen($suffix))) {
1124: static::reportInvalidArgument(\sprintf(
1125: $message ?: 'Expected a value not to end with %2$s. Got: %s',
1126: static::valueToString($value),
1127: static::valueToString($suffix)
1128: ));
1129: }
1130: }
1131:
1132: /**
1133: * @psalm-pure
1134: *
1135: * @param string $value
1136: * @param string $pattern
1137: * @param string $message
1138: *
1139: * @throws InvalidArgumentException
1140: */
1141: public static function regex($value, $pattern, $message = '')
1142: {
1143: if (!\preg_match($pattern, $value)) {
1144: static::reportInvalidArgument(\sprintf(
1145: $message ?: 'The value %s does not match the expected pattern.',
1146: static::valueToString($value)
1147: ));
1148: }
1149: }
1150:
1151: /**
1152: * @psalm-pure
1153: *
1154: * @param string $value
1155: * @param string $pattern
1156: * @param string $message
1157: *
1158: * @throws InvalidArgumentException
1159: */
1160: public static function notRegex($value, $pattern, $message = '')
1161: {
1162: if (\preg_match($pattern, $value, $matches, PREG_OFFSET_CAPTURE)) {
1163: static::reportInvalidArgument(\sprintf(
1164: $message ?: 'The value %s matches the pattern %s (at offset %d).',
1165: static::valueToString($value),
1166: static::valueToString($pattern),
1167: $matches[0][1]
1168: ));
1169: }
1170: }
1171:
1172: /**
1173: * @psalm-pure
1174: *
1175: * @param mixed $value
1176: * @param string $message
1177: *
1178: * @throws InvalidArgumentException
1179: */
1180: public static function unicodeLetters($value, $message = '')
1181: {
1182: static::string($value);
1183:
1184: if (!\preg_match('/^\p{L}+$/u', $value)) {
1185: static::reportInvalidArgument(\sprintf(
1186: $message ?: 'Expected a value to contain only Unicode letters. Got: %s',
1187: static::valueToString($value)
1188: ));
1189: }
1190: }
1191:
1192: /**
1193: * @psalm-pure
1194: *
1195: * @param mixed $value
1196: * @param string $message
1197: *
1198: * @throws InvalidArgumentException
1199: */
1200: public static function alpha($value, $message = '')
1201: {
1202: static::string($value);
1203:
1204: $locale = \setlocale(LC_CTYPE, 0);
1205: \setlocale(LC_CTYPE, 'C');
1206: $valid = !\ctype_alpha($value);
1207: \setlocale(LC_CTYPE, $locale);
1208:
1209: if ($valid) {
1210: static::reportInvalidArgument(\sprintf(
1211: $message ?: 'Expected a value to contain only letters. Got: %s',
1212: static::valueToString($value)
1213: ));
1214: }
1215: }
1216:
1217: /**
1218: * @psalm-pure
1219: *
1220: * @param string $value
1221: * @param string $message
1222: *
1223: * @throws InvalidArgumentException
1224: */
1225: public static function digits($value, $message = '')
1226: {
1227: $locale = \setlocale(LC_CTYPE, 0);
1228: \setlocale(LC_CTYPE, 'C');
1229: $valid = !\ctype_digit($value);
1230: \setlocale(LC_CTYPE, $locale);
1231:
1232: if ($valid) {
1233: static::reportInvalidArgument(\sprintf(
1234: $message ?: 'Expected a value to contain digits only. Got: %s',
1235: static::valueToString($value)
1236: ));
1237: }
1238: }
1239:
1240: /**
1241: * @psalm-pure
1242: *
1243: * @param string $value
1244: * @param string $message
1245: *
1246: * @throws InvalidArgumentException
1247: */
1248: public static function alnum($value, $message = '')
1249: {
1250: $locale = \setlocale(LC_CTYPE, 0);
1251: \setlocale(LC_CTYPE, 'C');
1252: $valid = !\ctype_alnum($value);
1253: \setlocale(LC_CTYPE, $locale);
1254:
1255: if ($valid) {
1256: static::reportInvalidArgument(\sprintf(
1257: $message ?: 'Expected a value to contain letters and digits only. Got: %s',
1258: static::valueToString($value)
1259: ));
1260: }
1261: }
1262:
1263: /**
1264: * @psalm-pure
1265: * @psalm-assert lowercase-string $value
1266: *
1267: * @param string $value
1268: * @param string $message
1269: *
1270: * @throws InvalidArgumentException
1271: */
1272: public static function lower($value, $message = '')
1273: {
1274: $locale = \setlocale(LC_CTYPE, 0);
1275: \setlocale(LC_CTYPE, 'C');
1276: $valid = !\ctype_lower($value);
1277: \setlocale(LC_CTYPE, $locale);
1278:
1279: if ($valid) {
1280: static::reportInvalidArgument(\sprintf(
1281: $message ?: 'Expected a value to contain lowercase characters only. Got: %s',
1282: static::valueToString($value)
1283: ));
1284: }
1285: }
1286:
1287: /**
1288: * @psalm-pure
1289: * @psalm-assert !lowercase-string $value
1290: *
1291: * @param string $value
1292: * @param string $message
1293: *
1294: * @throws InvalidArgumentException
1295: */
1296: public static function upper($value, $message = '')
1297: {
1298: $locale = \setlocale(LC_CTYPE, 0);
1299: \setlocale(LC_CTYPE, 'C');
1300: $valid = !\ctype_upper($value);
1301: \setlocale(LC_CTYPE, $locale);
1302:
1303: if ($valid) {
1304: static::reportInvalidArgument(\sprintf(
1305: $message ?: 'Expected a value to contain uppercase characters only. Got: %s',
1306: static::valueToString($value)
1307: ));
1308: }
1309: }
1310:
1311: /**
1312: * @psalm-pure
1313: *
1314: * @param string $value
1315: * @param int $length
1316: * @param string $message
1317: *
1318: * @throws InvalidArgumentException
1319: */
1320: public static function length($value, $length, $message = '')
1321: {
1322: if ($length !== static::strlen($value)) {
1323: static::reportInvalidArgument(\sprintf(
1324: $message ?: 'Expected a value to contain %2$s characters. Got: %s',
1325: static::valueToString($value),
1326: $length
1327: ));
1328: }
1329: }
1330:
1331: /**
1332: * Inclusive min.
1333: *
1334: * @psalm-pure
1335: *
1336: * @param string $value
1337: * @param int|float $min
1338: * @param string $message
1339: *
1340: * @throws InvalidArgumentException
1341: */
1342: public static function minLength($value, $min, $message = '')
1343: {
1344: if (static::strlen($value) < $min) {
1345: static::reportInvalidArgument(\sprintf(
1346: $message ?: 'Expected a value to contain at least %2$s characters. Got: %s',
1347: static::valueToString($value),
1348: $min
1349: ));
1350: }
1351: }
1352:
1353: /**
1354: * Inclusive max.
1355: *
1356: * @psalm-pure
1357: *
1358: * @param string $value
1359: * @param int|float $max
1360: * @param string $message
1361: *
1362: * @throws InvalidArgumentException
1363: */
1364: public static function maxLength($value, $max, $message = '')
1365: {
1366: if (static::strlen($value) > $max) {
1367: static::reportInvalidArgument(\sprintf(
1368: $message ?: 'Expected a value to contain at most %2$s characters. Got: %s',
1369: static::valueToString($value),
1370: $max
1371: ));
1372: }
1373: }
1374:
1375: /**
1376: * Inclusive , so Assert::lengthBetween('asd', 3, 5); passes the assertion.
1377: *
1378: * @psalm-pure
1379: *
1380: * @param string $value
1381: * @param int|float $min
1382: * @param int|float $max
1383: * @param string $message
1384: *
1385: * @throws InvalidArgumentException
1386: */
1387: public static function lengthBetween($value, $min, $max, $message = '')
1388: {
1389: $length = static::strlen($value);
1390:
1391: if ($length < $min || $length > $max) {
1392: static::reportInvalidArgument(\sprintf(
1393: $message ?: 'Expected a value to contain between %2$s and %3$s characters. Got: %s',
1394: static::valueToString($value),
1395: $min,
1396: $max
1397: ));
1398: }
1399: }
1400:
1401: /**
1402: * Will also pass if $value is a directory, use Assert::file() instead if you need to be sure it is a file.
1403: *
1404: * @param mixed $value
1405: * @param string $message
1406: *
1407: * @throws InvalidArgumentException
1408: */
1409: public static function fileExists($value, $message = '')
1410: {
1411: static::string($value);
1412:
1413: if (!\file_exists($value)) {
1414: static::reportInvalidArgument(\sprintf(
1415: $message ?: 'The file %s does not exist.',
1416: static::valueToString($value)
1417: ));
1418: }
1419: }
1420:
1421: /**
1422: * @param mixed $value
1423: * @param string $message
1424: *
1425: * @throws InvalidArgumentException
1426: */
1427: public static function file($value, $message = '')
1428: {
1429: static::fileExists($value, $message);
1430:
1431: if (!\is_file($value)) {
1432: static::reportInvalidArgument(\sprintf(
1433: $message ?: 'The path %s is not a file.',
1434: static::valueToString($value)
1435: ));
1436: }
1437: }
1438:
1439: /**
1440: * @param mixed $value
1441: * @param string $message
1442: *
1443: * @throws InvalidArgumentException
1444: */
1445: public static function directory($value, $message = '')
1446: {
1447: static::fileExists($value, $message);
1448:
1449: if (!\is_dir($value)) {
1450: static::reportInvalidArgument(\sprintf(
1451: $message ?: 'The path %s is no directory.',
1452: static::valueToString($value)
1453: ));
1454: }
1455: }
1456:
1457: /**
1458: * @param string $value
1459: * @param string $message
1460: *
1461: * @throws InvalidArgumentException
1462: */
1463: public static function readable($value, $message = '')
1464: {
1465: if (!\is_readable($value)) {
1466: static::reportInvalidArgument(\sprintf(
1467: $message ?: 'The path %s is not readable.',
1468: static::valueToString($value)
1469: ));
1470: }
1471: }
1472:
1473: /**
1474: * @param string $value
1475: * @param string $message
1476: *
1477: * @throws InvalidArgumentException
1478: */
1479: public static function writable($value, $message = '')
1480: {
1481: if (!\is_writable($value)) {
1482: static::reportInvalidArgument(\sprintf(
1483: $message ?: 'The path %s is not writable.',
1484: static::valueToString($value)
1485: ));
1486: }
1487: }
1488:
1489: /**
1490: * @psalm-assert class-string $value
1491: *
1492: * @param mixed $value
1493: * @param string $message
1494: *
1495: * @throws InvalidArgumentException
1496: */
1497: public static function classExists($value, $message = '')
1498: {
1499: if (!\class_exists($value)) {
1500: static::reportInvalidArgument(\sprintf(
1501: $message ?: 'Expected an existing class name. Got: %s',
1502: static::valueToString($value)
1503: ));
1504: }
1505: }
1506:
1507: /**
1508: * @psalm-pure
1509: * @psalm-template ExpectedType of object
1510: * @psalm-param class-string<ExpectedType> $class
1511: * @psalm-assert class-string<ExpectedType>|ExpectedType $value
1512: *
1513: * @param mixed $value
1514: * @param string|object $class
1515: * @param string $message
1516: *
1517: * @throws InvalidArgumentException
1518: */
1519: public static function subclassOf($value, $class, $message = '')
1520: {
1521: if (!\is_subclass_of($value, $class)) {
1522: static::reportInvalidArgument(\sprintf(
1523: $message ?: 'Expected a sub-class of %2$s. Got: %s',
1524: static::valueToString($value),
1525: static::valueToString($class)
1526: ));
1527: }
1528: }
1529:
1530: /**
1531: * @psalm-assert class-string $value
1532: *
1533: * @param mixed $value
1534: * @param string $message
1535: *
1536: * @throws InvalidArgumentException
1537: */
1538: public static function interfaceExists($value, $message = '')
1539: {
1540: if (!\interface_exists($value)) {
1541: static::reportInvalidArgument(\sprintf(
1542: $message ?: 'Expected an existing interface name. got %s',
1543: static::valueToString($value)
1544: ));
1545: }
1546: }
1547:
1548: /**
1549: * @psalm-pure
1550: * @psalm-template ExpectedType of object
1551: * @psalm-param class-string<ExpectedType> $interface
1552: * @psalm-assert class-string<ExpectedType> $value
1553: *
1554: * @param mixed $value
1555: * @param mixed $interface
1556: * @param string $message
1557: *
1558: * @throws InvalidArgumentException
1559: */
1560: public static function implementsInterface($value, $interface, $message = '')
1561: {
1562: if (!\in_array($interface, \class_implements($value))) {
1563: static::reportInvalidArgument(\sprintf(
1564: $message ?: 'Expected an implementation of %2$s. Got: %s',
1565: static::valueToString($value),
1566: static::valueToString($interface)
1567: ));
1568: }
1569: }
1570:
1571: /**
1572: * @psalm-pure
1573: * @psalm-param class-string|object $classOrObject
1574: *
1575: * @param string|object $classOrObject
1576: * @param mixed $property
1577: * @param string $message
1578: *
1579: * @throws InvalidArgumentException
1580: */
1581: public static function propertyExists($classOrObject, $property, $message = '')
1582: {
1583: if (!\property_exists($classOrObject, $property)) {
1584: static::reportInvalidArgument(\sprintf(
1585: $message ?: 'Expected the property %s to exist.',
1586: static::valueToString($property)
1587: ));
1588: }
1589: }
1590:
1591: /**
1592: * @psalm-pure
1593: * @psalm-param class-string|object $classOrObject
1594: *
1595: * @param string|object $classOrObject
1596: * @param mixed $property
1597: * @param string $message
1598: *
1599: * @throws InvalidArgumentException
1600: */
1601: public static function propertyNotExists($classOrObject, $property, $message = '')
1602: {
1603: if (\property_exists($classOrObject, $property)) {
1604: static::reportInvalidArgument(\sprintf(
1605: $message ?: 'Expected the property %s to not exist.',
1606: static::valueToString($property)
1607: ));
1608: }
1609: }
1610:
1611: /**
1612: * @psalm-pure
1613: * @psalm-param class-string|object $classOrObject
1614: *
1615: * @param string|object $classOrObject
1616: * @param mixed $method
1617: * @param string $message
1618: *
1619: * @throws InvalidArgumentException
1620: */
1621: public static function methodExists($classOrObject, $method, $message = '')
1622: {
1623: if (!(\is_string($classOrObject) || \is_object($classOrObject)) || !\method_exists($classOrObject, $method)) {
1624: static::reportInvalidArgument(\sprintf(
1625: $message ?: 'Expected the method %s to exist.',
1626: static::valueToString($method)
1627: ));
1628: }
1629: }
1630:
1631: /**
1632: * @psalm-pure
1633: * @psalm-param class-string|object $classOrObject
1634: *
1635: * @param string|object $classOrObject
1636: * @param mixed $method
1637: * @param string $message
1638: *
1639: * @throws InvalidArgumentException
1640: */
1641: public static function methodNotExists($classOrObject, $method, $message = '')
1642: {
1643: if ((\is_string($classOrObject) || \is_object($classOrObject)) && \method_exists($classOrObject, $method)) {
1644: static::reportInvalidArgument(\sprintf(
1645: $message ?: 'Expected the method %s to not exist.',
1646: static::valueToString($method)
1647: ));
1648: }
1649: }
1650:
1651: /**
1652: * @psalm-pure
1653: *
1654: * @param array $array
1655: * @param string|int $key
1656: * @param string $message
1657: *
1658: * @throws InvalidArgumentException
1659: */
1660: public static function keyExists($array, $key, $message = '')
1661: {
1662: if (!(isset($array[$key]) || \array_key_exists($key, $array))) {
1663: static::reportInvalidArgument(\sprintf(
1664: $message ?: 'Expected the key %s to exist.',
1665: static::valueToString($key)
1666: ));
1667: }
1668: }
1669:
1670: /**
1671: * @psalm-pure
1672: *
1673: * @param array $array
1674: * @param string|int $key
1675: * @param string $message
1676: *
1677: * @throws InvalidArgumentException
1678: */
1679: public static function keyNotExists($array, $key, $message = '')
1680: {
1681: if (isset($array[$key]) || \array_key_exists($key, $array)) {
1682: static::reportInvalidArgument(\sprintf(
1683: $message ?: 'Expected the key %s to not exist.',
1684: static::valueToString($key)
1685: ));
1686: }
1687: }
1688:
1689: /**
1690: * Checks if a value is a valid array key (int or string).
1691: *
1692: * @psalm-pure
1693: * @psalm-assert array-key $value
1694: *
1695: * @param mixed $value
1696: * @param string $message
1697: *
1698: * @throws InvalidArgumentException
1699: */
1700: public static function validArrayKey($value, $message = '')
1701: {
1702: if (!(\is_int($value) || \is_string($value))) {
1703: static::reportInvalidArgument(\sprintf(
1704: $message ?: 'Expected string or integer. Got: %s',
1705: static::typeToString($value)
1706: ));
1707: }
1708: }
1709:
1710: /**
1711: * Does not check if $array is countable, this can generate a warning on php versions after 7.2.
1712: *
1713: * @param Countable|array $array
1714: * @param int $number
1715: * @param string $message
1716: *
1717: * @throws InvalidArgumentException
1718: */
1719: public static function count($array, $number, $message = '')
1720: {
1721: static::eq(
1722: \count($array),
1723: $number,
1724: \sprintf(
1725: $message ?: 'Expected an array to contain %d elements. Got: %d.',
1726: $number,
1727: \count($array)
1728: )
1729: );
1730: }
1731:
1732: /**
1733: * Does not check if $array is countable, this can generate a warning on php versions after 7.2.
1734: *
1735: * @param Countable|array $array
1736: * @param int|float $min
1737: * @param string $message
1738: *
1739: * @throws InvalidArgumentException
1740: */
1741: public static function minCount($array, $min, $message = '')
1742: {
1743: if (\count($array) < $min) {
1744: static::reportInvalidArgument(\sprintf(
1745: $message ?: 'Expected an array to contain at least %2$d elements. Got: %d',
1746: \count($array),
1747: $min
1748: ));
1749: }
1750: }
1751:
1752: /**
1753: * Does not check if $array is countable, this can generate a warning on php versions after 7.2.
1754: *
1755: * @param Countable|array $array
1756: * @param int|float $max
1757: * @param string $message
1758: *
1759: * @throws InvalidArgumentException
1760: */
1761: public static function maxCount($array, $max, $message = '')
1762: {
1763: if (\count($array) > $max) {
1764: static::reportInvalidArgument(\sprintf(
1765: $message ?: 'Expected an array to contain at most %2$d elements. Got: %d',
1766: \count($array),
1767: $max
1768: ));
1769: }
1770: }
1771:
1772: /**
1773: * Does not check if $array is countable, this can generate a warning on php versions after 7.2.
1774: *
1775: * @param Countable|array $array
1776: * @param int|float $min
1777: * @param int|float $max
1778: * @param string $message
1779: *
1780: * @throws InvalidArgumentException
1781: */
1782: public static function countBetween($array, $min, $max, $message = '')
1783: {
1784: $count = \count($array);
1785:
1786: if ($count < $min || $count > $max) {
1787: static::reportInvalidArgument(\sprintf(
1788: $message ?: 'Expected an array to contain between %2$d and %3$d elements. Got: %d',
1789: $count,
1790: $min,
1791: $max
1792: ));
1793: }
1794: }
1795:
1796: /**
1797: * @psalm-pure
1798: * @psalm-assert list $array
1799: *
1800: * @param mixed $array
1801: * @param string $message
1802: *
1803: * @throws InvalidArgumentException
1804: */
1805: public static function isList($array, $message = '')
1806: {
1807: if (!\is_array($array) || $array !== \array_values($array)) {
1808: static::reportInvalidArgument(
1809: $message ?: 'Expected list - non-associative array.'
1810: );
1811: }
1812: }
1813:
1814: /**
1815: * @psalm-pure
1816: * @psalm-assert non-empty-list $array
1817: *
1818: * @param mixed $array
1819: * @param string $message
1820: *
1821: * @throws InvalidArgumentException
1822: */
1823: public static function isNonEmptyList($array, $message = '')
1824: {
1825: static::isList($array, $message);
1826: static::notEmpty($array, $message);
1827: }
1828:
1829: /**
1830: * @psalm-pure
1831: * @psalm-template T
1832: * @psalm-param mixed|array<T> $array
1833: * @psalm-assert array<string, T> $array
1834: *
1835: * @param mixed $array
1836: * @param string $message
1837: *
1838: * @throws InvalidArgumentException
1839: */
1840: public static function isMap($array, $message = '')
1841: {
1842: if (
1843: !\is_array($array) ||
1844: \array_keys($array) !== \array_filter(\array_keys($array), '\is_string')
1845: ) {
1846: static::reportInvalidArgument(
1847: $message ?: 'Expected map - associative array with string keys.'
1848: );
1849: }
1850: }
1851:
1852: /**
1853: * @psalm-pure
1854: * @psalm-template T
1855: * @psalm-param mixed|array<T> $array
1856: * @psalm-assert array<string, T> $array
1857: * @psalm-assert !empty $array
1858: *
1859: * @param mixed $array
1860: * @param string $message
1861: *
1862: * @throws InvalidArgumentException
1863: */
1864: public static function isNonEmptyMap($array, $message = '')
1865: {
1866: static::isMap($array, $message);
1867: static::notEmpty($array, $message);
1868: }
1869:
1870: /**
1871: * @psalm-pure
1872: *
1873: * @param string $value
1874: * @param string $message
1875: *
1876: * @throws InvalidArgumentException
1877: */
1878: public static function uuid($value, $message = '')
1879: {
1880: $value = \str_replace(array('urn:', 'uuid:', '{', '}'), '', $value);
1881:
1882: // The nil UUID is special form of UUID that is specified to have all
1883: // 128 bits set to zero.
1884: if ('00000000-0000-0000-0000-000000000000' === $value) {
1885: return;
1886: }
1887:
1888: if (!\preg_match('/^[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}$/', $value)) {
1889: static::reportInvalidArgument(\sprintf(
1890: $message ?: 'Value %s is not a valid UUID.',
1891: static::valueToString($value)
1892: ));
1893: }
1894: }
1895:
1896: /**
1897: * @psalm-param class-string<Throwable> $class
1898: *
1899: * @param Closure $expression
1900: * @param string $class
1901: * @param string $message
1902: *
1903: * @throws InvalidArgumentException
1904: */
1905: public static function throws(Closure $expression, $class = 'Exception', $message = '')
1906: {
1907: static::string($class);
1908:
1909: $actual = 'none';
1910:
1911: try {
1912: $expression();
1913: } catch (Exception $e) {
1914: $actual = \get_class($e);
1915: if ($e instanceof $class) {
1916: return;
1917: }
1918: } catch (Throwable $e) {
1919: $actual = \get_class($e);
1920: if ($e instanceof $class) {
1921: return;
1922: }
1923: }
1924:
1925: static::reportInvalidArgument($message ?: \sprintf(
1926: 'Expected to throw "%s", got "%s"',
1927: $class,
1928: $actual
1929: ));
1930: }
1931:
1932: /**
1933: * @throws BadMethodCallException
1934: */
1935: public static function __callStatic($name, $arguments)
1936: {
1937: if ('nullOr' === \substr($name, 0, 6)) {
1938: if (null !== $arguments[0]) {
1939: $method = \lcfirst(\substr($name, 6));
1940: \call_user_func_array(array('static', $method), $arguments);
1941: }
1942:
1943: return;
1944: }
1945:
1946: if ('all' === \substr($name, 0, 3)) {
1947: static::isIterable($arguments[0]);
1948:
1949: $method = \lcfirst(\substr($name, 3));
1950: $args = $arguments;
1951:
1952: foreach ($arguments[0] as $entry) {
1953: $args[0] = $entry;
1954:
1955: \call_user_func_array(array('static', $method), $args);
1956: }
1957:
1958: return;
1959: }
1960:
1961: throw new BadMethodCallException('No such method: '.$name);
1962: }
1963:
1964: /**
1965: * @param mixed $value
1966: *
1967: * @return string
1968: */
1969: protected static function valueToString($value)
1970: {
1971: if (null === $value) {
1972: return 'null';
1973: }
1974:
1975: if (true === $value) {
1976: return 'true';
1977: }
1978:
1979: if (false === $value) {
1980: return 'false';
1981: }
1982:
1983: if (\is_array($value)) {
1984: return 'array';
1985: }
1986:
1987: if (\is_object($value)) {
1988: if (\method_exists($value, '__toString')) {
1989: return \get_class($value).': '.self::valueToString($value->__toString());
1990: }
1991:
1992: if ($value instanceof DateTime || $value instanceof DateTimeImmutable) {
1993: return \get_class($value).': '.self::valueToString($value->format('c'));
1994: }
1995:
1996: return \get_class($value);
1997: }
1998:
1999: if (\is_resource($value)) {
2000: return 'resource';
2001: }
2002:
2003: if (\is_string($value)) {
2004: return '"'.$value.'"';
2005: }
2006:
2007: return (string) $value;
2008: }
2009:
2010: /**
2011: * @param mixed $value
2012: *
2013: * @return string
2014: */
2015: protected static function typeToString($value)
2016: {
2017: return \is_object($value) ? \get_class($value) : \gettype($value);
2018: }
2019:
2020: protected static function strlen($value)
2021: {
2022: if (!\function_exists('mb_detect_encoding')) {
2023: return \strlen($value);
2024: }
2025:
2026: if (false === $encoding = \mb_detect_encoding($value)) {
2027: return \strlen($value);
2028: }
2029:
2030: return \mb_strlen($value, $encoding);
2031: }
2032:
2033: /**
2034: * @param string $message
2035: *
2036: * @throws InvalidArgumentException
2037: *
2038: * @psalm-pure this method is not supposed to perform side-effects
2039: */
2040: protected static function reportInvalidArgument($message)
2041: {
2042: throw new InvalidArgumentException($message);
2043: }
2044:
2045: private function __construct()
2046: {
2047: }
2048: }
2049:
API documentation generated by ApiGen v7.0.0-alpha.6