/Front_End/vendor/webmozart/assert/src/Assert.php

https://gitlab.com/Sigpot/AirSpot · PHP · 903 lines · 669 code · 98 blank · 136 comment · 82 complexity · 1dfd4c1c5573ba303d5fc7118d7a915b MD5 · raw file 

    

  1. <?php
    2. 

  2. 

  3. /*
    4. 

  4.  * This file is part of the webmozart/assert package.
    5. 

  5.  *
    6. 

  6.  * (c) Bernhard Schussek <bschussek@gmail.com>
    7. 

  7.  *
    8. 

  8.  * For the full copyright and license information, please view the LICENSE
    9. 

  9.  * file that was distributed with this source code.
    10. 

  10.  */
    11. 

  11. 

  12. namespace Webmozart\Assert;
    13. 

  13. 

  14. use BadMethodCallException;
    15. 

  15. use InvalidArgumentException;
    16. 

  16. use Traversable;
    17. 

  17. 

  18. /**
    19. 

  19.  * Efficient assertions to validate the input/output of your methods.
    20. 

  20.  *
    21. 

  21.  * @method static void nullOrString($value, $message = '')
    22. 

  22.  * @method static void nullOrStringNotEmpty($value, $message = '')
    23. 

  23.  * @method static void nullOrInteger($value, $message = '')
    24. 

  24.  * @method static void nullOrIntegerish($value, $message = '')
    25. 

  25.  * @method static void nullOrFloat($value, $message = '')
    26. 

  26.  * @method static void nullOrNumeric($value, $message = '')
    27. 

  27.  * @method static void nullOrBoolean($value, $message = '')
    28. 

  28.  * @method static void nullOrScalar($value, $message = '')
    29. 

  29.  * @method static void nullOrObject($value, $message = '')
    30. 

  30.  * @method static void nullOrResource($value, $type = null, $message = '')
    31. 

  31.  * @method static void nullOrIsCallable($value, $message = '')
    32. 

  32.  * @method static void nullOrIsArray($value, $message = '')
    33. 

  33.  * @method static void nullOrIsTraversable($value, $message = '')
    34. 

  34.  * @method static void nullOrIsInstanceOf($value, $class, $message = '')
    35. 

  35.  * @method static void nullOrNotInstanceOf($value, $class, $message = '')
    36. 

  36.  * @method static void nullOrIsEmpty($value, $message = '')
    37. 

  37.  * @method static void nullOrNotEmpty($value, $message = '')
    38. 

  38.  * @method static void nullOrTrue($value, $message = '')
    39. 

  39.  * @method static void nullOrFalse($value, $message = '')
    40. 

  40.  * @method static void nullOrEq($value, $value2, $message = '')
    41. 

  41.  * @method static void nullOrNotEq($value,$value2,  $message = '')
    42. 

  42.  * @method static void nullOrSame($value, $value2, $message = '')
    43. 

  43.  * @method static void nullOrNotSame($value, $value2, $message = '')
    44. 

  44.  * @method static void nullOrGreaterThan($value, $value2, $message = '')
    45. 

  45.  * @method static void nullOrGreaterThanEq($value, $value2, $message = '')
    46. 

  46.  * @method static void nullOrLessThan($value, $value2, $message = '')
    47. 

  47.  * @method static void nullOrLessThanEq($value, $value2, $message = '')
    48. 

  48.  * @method static void nullOrRange($value, $min, $max, $message = '')
    49. 

  49.  * @method static void nullOrOneOf($value, $values, $message = '')
    50. 

  50.  * @method static void nullOrContains($value, $subString, $message = '')
    51. 

  51.  * @method static void nullOrStartsWith($value, $prefix, $message = '')
    52. 

  52.  * @method static void nullOrStartsWithLetter($value, $message = '')
    53. 

  53.  * @method static void nullOrEndsWith($value, $suffix, $message = '')
    54. 

  54.  * @method static void nullOrRegex($value, $pattern, $message = '')
    55. 

  55.  * @method static void nullOrAlpha($value, $message = '')
    56. 

  56.  * @method static void nullOrDigits($value, $message = '')
    57. 

  57.  * @method static void nullOrAlnum($value, $message = '')
    58. 

  58.  * @method static void nullOrLower($value, $message = '')
    59. 

  59.  * @method static void nullOrUpper($value, $message = '')
    60. 

  60.  * @method static void nullOrLength($value, $length, $message = '')
    61. 

  61.  * @method static void nullOrMinLength($value, $min, $message = '')
    62. 

  62.  * @method static void nullOrMaxLength($value, $max, $message = '')
    63. 

  63.  * @method static void nullOrLengthBetween($value, $min, $max, $message = '')
    64. 

  64.  * @method static void nullOrFileExists($value, $message = '')
    65. 

  65.  * @method static void nullOrFile($value, $message = '')
    66. 

  66.  * @method static void nullOrDirectory($value, $message = '')
    67. 

  67.  * @method static void nullOrReadable($value, $message = '')
    68. 

  68.  * @method static void nullOrWritable($value, $message = '')
    69. 

  69.  * @method static void nullOrClassExists($value, $message = '')
    70. 

  70.  * @method static void nullOrSubclassOf($value, $class, $message = '')
    71. 

  71.  * @method static void nullOrImplementsInterface($value, $interface, $message = '')
    72. 

  72.  * @method static void nullOrPropertyExists($value, $property, $message = '')
    73. 

  73.  * @method static void nullOrPropertyNotExists($value, $property, $message = '')
    74. 

  74.  * @method static void nullOrMethodExists($value, $method, $message = '')
    75. 

  75.  * @method static void nullOrMethodNotExists($value, $method, $message = '')
    76. 

  76.  * @method static void nullOrKeyExists($value, $key, $message = '')
    77. 

  77.  * @method static void nullOrKeyNotExists($value, $key, $message = '')
    78. 

  78.  * @method static void nullOrUuid($values, $message = '')
    79. 

  79.  * @method static void allString($values, $message = '')
    80. 

  80.  * @method static void allStringNotEmpty($values, $message = '')
    81. 

  81.  * @method static void allInteger($values, $message = '')
    82. 

  82.  * @method static void allIntegerish($values, $message = '')
    83. 

  83.  * @method static void allFloat($values, $message = '')
    84. 

  84.  * @method static void allNumeric($values, $message = '')
    85. 

  85.  * @method static void allBoolean($values, $message = '')
    86. 

  86.  * @method static void allScalar($values, $message = '')
    87. 

  87.  * @method static void allObject($values, $message = '')
    88. 

  88.  * @method static void allResource($values, $type = null, $message = '')
    89. 

  89.  * @method static void allIsCallable($values, $message = '')
    90. 

  90.  * @method static void allIsArray($values, $message = '')
    91. 

  91.  * @method static void allIsTraversable($values, $message = '')
    92. 

  92.  * @method static void allIsInstanceOf($values, $class, $message = '')
    93. 

  93.  * @method static void allNotInstanceOf($values, $class, $message = '')
    94. 

  94.  * @method static void allNull($values, $message = '')
    95. 

  95.  * @method static void allNotNull($values, $message = '')
    96. 

  96.  * @method static void allIsEmpty($values, $message = '')
    97. 

  97.  * @method static void allNotEmpty($values, $message = '')
    98. 

  98.  * @method static void allTrue($values, $message = '')
    99. 

  99.  * @method static void allFalse($values, $message = '')
    100. 

  100.  * @method static void allEq($values, $value2, $message = '')
    101. 

  101.  * @method static void allNotEq($values,$value2,  $message = '')
    102. 

  102.  * @method static void allSame($values, $value2, $message = '')
    103. 

  103.  * @method static void allNotSame($values, $value2, $message = '')
    104. 

  104.  * @method static void allGreaterThan($values, $value2, $message = '')
    105. 

  105.  * @method static void allGreaterThanEq($values, $value2, $message = '')
    106. 

  106.  * @method static void allLessThan($values, $value2, $message = '')
    107. 

  107.  * @method static void allLessThanEq($values, $value2, $message = '')
    108. 

  108.  * @method static void allRange($values, $min, $max, $message = '')
    109. 

  109.  * @method static void allOneOf($values, $values, $message = '')
    110. 

  110.  * @method static void allContains($values, $subString, $message = '')
    111. 

  111.  * @method static void allStartsWith($values, $prefix, $message = '')
    112. 

  112.  * @method static void allStartsWithLetter($values, $message = '')
    113. 

  113.  * @method static void allEndsWith($values, $suffix, $message = '')
    114. 

  114.  * @method static void allRegex($values, $pattern, $message = '')
    115. 

  115.  * @method static void allAlpha($values, $message = '')
    116. 

  116.  * @method static void allDigits($values, $message = '')
    117. 

  117.  * @method static void allAlnum($values, $message = '')
    118. 

  118.  * @method static void allLower($values, $message = '')
    119. 

  119.  * @method static void allUpper($values, $message = '')
    120. 

  120.  * @method static void allLength($values, $length, $message = '')
    121. 

  121.  * @method static void allMinLength($values, $min, $message = '')
    122. 

  122.  * @method static void allMaxLength($values, $max, $message = '')
    123. 

  123.  * @method static void allLengthBetween($values, $min, $max, $message = '')
    124. 

  124.  * @method static void allFileExists($values, $message = '')
    125. 

  125.  * @method static void allFile($values, $message = '')
    126. 

  126.  * @method static void allDirectory($values, $message = '')
    127. 

  127.  * @method static void allReadable($values, $message = '')
    128. 

  128.  * @method static void allWritable($values, $message = '')
    129. 

  129.  * @method static void allClassExists($values, $message = '')
    130. 

  130.  * @method static void allSubclassOf($values, $class, $message = '')
    131. 

  131.  * @method static void allImplementsInterface($values, $interface, $message = '')
    132. 

  132.  * @method static void allPropertyExists($values, $property, $message = '')
    133. 

  133.  * @method static void allPropertyNotExists($values, $property, $message = '')
    134. 

  134.  * @method static void allMethodExists($values, $method, $message = '')
    135. 

  135.  * @method static void allMethodNotExists($values, $method, $message = '')
    136. 

  136.  * @method static void allKeyExists($values, $key, $message = '')
    137. 

  137.  * @method static void allKeyNotExists($values, $key, $message = '')
    138. 

  138.  * @method static void allUuid($values, $message = '')
    139. 

  139.  *
    140. 

  140.  * @since  1.0
    141. 

  141.  *
    142. 

  142.  * @author Bernhard Schussek <bschussek@gmail.com>
    143. 

  143.  */
    144. 

  144. class Assert
    145. 

  145. {
    146. 

  146.     public static function string($value, $message = '')
    147. 

  147.     {
    148. 

  148.         if (!is_string($value)) {
    149. 

  149.             throw new InvalidArgumentException(sprintf(
    150. 

  150.                 $message ?: 'Expected a string. Got: %s',
    151. 

  151.                 self::typeToString($value)
    152. 

  152.             ));
    153. 

  153.         }
    154. 

  154.     }
    155. 

  155. 

  156.     public static function stringNotEmpty($value, $message = '')
    157. 

  157.     {
    158. 

  158.         self::string($value, $message);
    159. 

  159.         self::notEmpty($value, $message);
    160. 

  160.     }
    161. 

  161. 

  162.     public static function integer($value, $message = '')
    163. 

  163.     {
    164. 

  164.         if (!is_int($value)) {
    165. 

  165.             throw new InvalidArgumentException(sprintf(
    166. 

  166.                 $message ?: 'Expected an integer. Got: %s',
    167. 

  167.                 self::typeToString($value)
    168. 

  168.             ));
    169. 

  169.         }
    170. 

  170.     }
    171. 

  171. 

  172.     public static function integerish($value, $message = '')
    173. 

  173.     {
    174. 

  174.         if (!is_numeric($value) || $value != (int) $value) {
    175. 

  175.             throw new InvalidArgumentException(sprintf(
    176. 

  176.                 $message ?: 'Expected an integerish value. Got: %s',
    177. 

  177.                 self::typeToString($value)
    178. 

  178.             ));
    179. 

  179.         }
    180. 

  180.     }
    181. 

  181. 

  182.     public static function float($value, $message = '')
    183. 

  183.     {
    184. 

  184.         if (!is_float($value)) {
    185. 

  185.             throw new InvalidArgumentException(sprintf(
    186. 

  186.                 $message ?: 'Expected a float. Got: %s',
    187. 

  187.                 self::typeToString($value)
    188. 

  188.             ));
    189. 

  189.         }
    190. 

  190.     }
    191. 

  191. 

  192.     public static function numeric($value, $message = '')
    193. 

  193.     {
    194. 

  194.         if (!is_numeric($value)) {
    195. 

  195.             throw new InvalidArgumentException(sprintf(
    196. 

  196.                 $message ?: 'Expected a numeric. Got: %s',
    197. 

  197.                 self::typeToString($value)
    198. 

  198.             ));
    199. 

  199.         }
    200. 

  200.     }
    201. 

  201. 

  202.     public static function boolean($value, $message = '')
    203. 

  203.     {
    204. 

  204.         if (!is_bool($value)) {
    205. 

  205.             throw new InvalidArgumentException(sprintf(
    206. 

  206.                 $message ?: 'Expected a boolean. Got: %s',
    207. 

  207.                 self::typeToString($value)
    208. 

  208.             ));
    209. 

  209.         }
    210. 

  210.     }
    211. 

  211. 

  212.     public static function scalar($value, $message = '')
    213. 

  213.     {
    214. 

  214.         if (!is_scalar($value)) {
    215. 

  215.             throw new InvalidArgumentException(sprintf(
    216. 

  216.                 $message ?: 'Expected a scalar. Got: %s',
    217. 

  217.                 self::typeToString($value)
    218. 

  218.             ));
    219. 

  219.         }
    220. 

  220.     }
    221. 

  221. 

  222.     public static function object($value, $message = '')
    223. 

  223.     {
    224. 

  224.         if (!is_object($value)) {
    225. 

  225.             throw new InvalidArgumentException(sprintf(
    226. 

  226.                 $message ?: 'Expected an object. Got: %s',
    227. 

  227.                 self::typeToString($value)
    228. 

  228.             ));
    229. 

  229.         }
    230. 

  230.     }
    231. 

  231. 

  232.     public static function resource($value, $type = null, $message = '')
    233. 

  233.     {
    234. 

  234.         if (!is_resource($value)) {
    235. 

  235.             throw new InvalidArgumentException(sprintf(
    236. 

  236.                 $message ?: 'Expected a resource. Got: %s',
    237. 

  237.                 self::typeToString($value)
    238. 

  238.             ));
    239. 

  239.         }
    240. 

  240. 

  241.         if ($type && $type !== get_resource_type($value)) {
    242. 

  242.             throw new InvalidArgumentException(sprintf(
    243. 

  243.                 $message ?: 'Expected a resource of type %2$s. Got: %s',
    244. 

  244.                 self::typeToString($value),
    245. 

  245.                 $type
    246. 

  246.             ));
    247. 

  247.         }
    248. 

  248.     }
    249. 

  249. 

  250.     public static function isCallable($value, $message = '')
    251. 

  251.     {
    252. 

  252.         if (!is_callable($value)) {
    253. 

  253.             throw new InvalidArgumentException(sprintf(
    254. 

  254.                 $message ?: 'Expected a callable. Got: %s',
    255. 

  255.                 self::typeToString($value)
    256. 

  256.             ));
    257. 

  257.         }
    258. 

  258.     }
    259. 

  259. 

  260.     public static function isArray($value, $message = '')
    261. 

  261.     {
    262. 

  262.         if (!is_array($value)) {
    263. 

  263.             throw new InvalidArgumentException(sprintf(
    264. 

  264.                 $message ?: 'Expected an array. Got: %s',
    265. 

  265.                 self::typeToString($value)
    266. 

  266.             ));
    267. 

  267.         }
    268. 

  268.     }
    269. 

  269. 

  270.     public static function isTraversable($value, $message = '')
    271. 

  271.     {
    272. 

  272.         if (!is_array($value) && !($value instanceof Traversable)) {
    273. 

  273.             throw new InvalidArgumentException(sprintf(
    274. 

  274.                 $message ?: 'Expected a traversable. Got: %s',
    275. 

  275.                 self::typeToString($value)
    276. 

  276.             ));
    277. 

  277.         }
    278. 

  278.     }
    279. 

  279. 

  280.     public static function isInstanceOf($value, $class, $message = '')
    281. 

  281.     {
    282. 

  282.         if (!($value instanceof $class)) {
    283. 

  283.             throw new InvalidArgumentException(sprintf(
    284. 

  284.                 $message ?: 'Expected an instance of %2$s. Got: %s',
    285. 

  285.                 self::typeToString($value),
    286. 

  286.                 $class
    287. 

  287.             ));
    288. 

  288.         }
    289. 

  289.     }
    290. 

  290. 

  291.     public static function notInstanceOf($value, $class, $message = '')
    292. 

  292.     {
    293. 

  293.         if ($value instanceof $class) {
    294. 

  294.             throw new InvalidArgumentException(sprintf(
    295. 

  295.                 $message ?: 'Expected an instance other than %2$s. Got: %s',
    296. 

  296.                 self::typeToString($value),
    297. 

  297.                 $class
    298. 

  298.             ));
    299. 

  299.         }
    300. 

  300.     }
    301. 

  301. 

  302.     public static function isEmpty($value, $message = '')
    303. 

  303.     {
    304. 

  304.         if (!empty($value)) {
    305. 

  305.             throw new InvalidArgumentException(sprintf(
    306. 

  306.                 $message ?: 'Expected an empty value. Got: %s',
    307. 

  307.                 self::valueToString($value)
    308. 

  308.             ));
    309. 

  309.         }
    310. 

  310.     }
    311. 

  311. 

  312.     public static function notEmpty($value, $message = '')
    313. 

  313.     {
    314. 

  314.         if (empty($value)) {
    315. 

  315.             throw new InvalidArgumentException(sprintf(
    316. 

  316.                 $message ?: 'Expected a non-empty value. Got: %s',
    317. 

  317.                 self::valueToString($value)
    318. 

  318.             ));
    319. 

  319.         }
    320. 

  320.     }
    321. 

  321. 

  322.     public static function null($value, $message = '')
    323. 

  323.     {
    324. 

  324.         if (null !== $value) {
    325. 

  325.             throw new InvalidArgumentException(sprintf(
    326. 

  326.                 $message ?: 'Expected null. Got: %s',
    327. 

  327.                 self::valueToString($value)
    328. 

  328.             ));
    329. 

  329.         }
    330. 

  330.     }
    331. 

  331. 

  332.     public static function notNull($value, $message = '')
    333. 

  333.     {
    334. 

  334.         if (null === $value) {
    335. 

  335.             throw new InvalidArgumentException(
    336. 

  336.                 $message ?: 'Expected a value other than null.'
    337. 

  337.             );
    338. 

  338.         }
    339. 

  339.     }
    340. 

  340. 

  341.     public static function true($value, $message = '')
    342. 

  342.     {
    343. 

  343.         if (true !== $value) {
    344. 

  344.             throw new InvalidArgumentException(sprintf(
    345. 

  345.                 $message ?: 'Expected a value to be true. Got: %s',
    346. 

  346.                 self::valueToString($value)
    347. 

  347.             ));
    348. 

  348.         }
    349. 

  349.     }
    350. 

  350. 

  351.     public static function false($value, $message = '')
    352. 

  352.     {
    353. 

  353.         if (false !== $value) {
    354. 

  354.             throw new InvalidArgumentException(sprintf(
    355. 

  355.                 $message ?: 'Expected a value to be false. Got: %s',
    356. 

  356.                 self::valueToString($value)
    357. 

  357.             ));
    358. 

  358.         }
    359. 

  359.     }
    360. 

  360. 

  361.     public static function eq($value, $value2, $message = '')
    362. 

  362.     {
    363. 

  363.         if ($value2 != $value) {
    364. 

  364.             throw new InvalidArgumentException(sprintf(
    365. 

  365.                 $message ?: 'Expected a value equal to %2$s. Got: %s',
    366. 

  366.                 self::valueToString($value),
    367. 

  367.                 self::valueToString($value2)
    368. 

  368.             ));
    369. 

  369.         }
    370. 

  370.     }
    371. 

  371. 

  372.     public static function notEq($value, $value2, $message = '')
    373. 

  373.     {
    374. 

  374.         if ($value2 == $value) {
    375. 

  375.             throw new InvalidArgumentException(sprintf(
    376. 

  376.                 $message ?: 'Expected a different value than %s.',
    377. 

  377.                 self::valueToString($value2)
    378. 

  378.             ));
    379. 

  379.         }
    380. 

  380.     }
    381. 

  381. 

  382.     public static function same($value, $value2, $message = '')
    383. 

  383.     {
    384. 

  384.         if ($value2 !== $value) {
    385. 

  385.             throw new InvalidArgumentException(sprintf(
    386. 

  386.                 $message ?: 'Expected a value identical to %2$s. Got: %s',
    387. 

  387.                 self::valueToString($value),
    388. 

  388.                 self::valueToString($value2)
    389. 

  389.             ));
    390. 

  390.         }
    391. 

  391.     }
    392. 

  392. 

  393.     public static function notSame($value, $value2, $message = '')
    394. 

  394.     {
    395. 

  395.         if ($value2 === $value) {
    396. 

  396.             throw new InvalidArgumentException(sprintf(
    397. 

  397.                 $message ?: 'Expected a value not identical to %s.',
    398. 

  398.                 self::valueToString($value2)
    399. 

  399.             ));
    400. 

  400.         }
    401. 

  401.     }
    402. 

  402. 

  403.     public static function greaterThan($value, $limit, $message = '')
    404. 

  404.     {
    405. 

  405.         if ($value <= $limit) {
    406. 

  406.             throw new InvalidArgumentException(sprintf(
    407. 

  407.                 $message ?: 'Expected a value greater than %2$s. Got: %s',
    408. 

  408.                 self::valueToString($value),
    409. 

  409.                 self::valueToString($limit)
    410. 

  410.             ));
    411. 

  411.         }
    412. 

  412.     }
    413. 

  413. 

  414.     public static function greaterThanEq($value, $limit, $message = '')
    415. 

  415.     {
    416. 

  416.         if ($value < $limit) {
    417. 

  417.             throw new InvalidArgumentException(sprintf(
    418. 

  418.                 $message ?: 'Expected a value greater than or equal to %2$s. Got: %s',
    419. 

  419.                 self::valueToString($value),
    420. 

  420.                 self::valueToString($limit)
    421. 

  421.             ));
    422. 

  422.         }
    423. 

  423.     }
    424. 

  424. 

  425.     public static function lessThan($value, $limit, $message = '')
    426. 

  426.     {
    427. 

  427.         if ($value >= $limit) {
    428. 

  428.             throw new InvalidArgumentException(sprintf(
    429. 

  429.                 $message ?: 'Expected a value less than %2$s. Got: %s',
    430. 

  430.                 self::valueToString($value),
    431. 

  431.                 self::valueToString($limit)
    432. 

  432.             ));
    433. 

  433.         }
    434. 

  434.     }
    435. 

  435. 

  436.     public static function lessThanEq($value, $limit, $message = '')
    437. 

  437.     {
    438. 

  438.         if ($value > $limit) {
    439. 

  439.             throw new InvalidArgumentException(sprintf(
    440. 

  440.                 $message ?: 'Expected a value less than or equal to %2$s. Got: %s',
    441. 

  441.                 self::valueToString($value),
    442. 

  442.                 self::valueToString($limit)
    443. 

  443.             ));
    444. 

  444.         }
    445. 

  445.     }
    446. 

  446. 

  447.     public static function range($value, $min, $max, $message = '')
    448. 

  448.     {
    449. 

  449.         if ($value < $min || $value > $max) {
    450. 

  450.             throw new InvalidArgumentException(sprintf(
    451. 

  451.                 $message ?: 'Expected a value between %2$s and %3$s. Got: %s',
    452. 

  452.                 self::valueToString($value),
    453. 

  453.                 self::valueToString($min),
    454. 

  454.                 self::valueToString($max)
    455. 

  455.             ));
    456. 

  456.         }
    457. 

  457.     }
    458. 

  458. 

  459.     public static function oneOf($value, array $values, $message = '')
    460. 

  460.     {
    461. 

  461.         if (!in_array($value, $values, true)) {
    462. 

  462.             throw new InvalidArgumentException(sprintf(
    463. 

  463.                 $message ?: 'Expected one of: %2$s. Got: %s',
    464. 

  464.                 self::valueToString($value),
    465. 

  465.                 implode(', ', array_map(array(__CLASS__, 'valueToString'), $values))
    466. 

  466.             ));
    467. 

  467.         }
    468. 

  468.     }
    469. 

  469. 

  470.     public static function contains($value, $subString, $message = '')
    471. 

  471.     {
    472. 

  472.         if (false === strpos($value, $subString)) {
    473. 

  473.             throw new InvalidArgumentException(sprintf(
    474. 

  474.                 $message ?: 'Expected a value to contain %2$s. Got: %s',
    475. 

  475.                 self::valueToString($value),
    476. 

  476.                 self::valueToString($subString)
    477. 

  477.             ));
    478. 

  478.         }
    479. 

  479.     }
    480. 

  480. 

  481.     public static function startsWith($value, $prefix, $message = '')
    482. 

  482.     {
    483. 

  483.         if (0 !== strpos($value, $prefix)) {
    484. 

  484.             throw new InvalidArgumentException(sprintf(
    485. 

  485.                 $message ?: 'Expected a value to start with %2$s. Got: %s',
    486. 

  486.                 self::valueToString($value),
    487. 

  487.                 self::valueToString($prefix)
    488. 

  488.             ));
    489. 

  489.         }
    490. 

  490.     }
    491. 

  491. 

  492.     public static function startsWithLetter($value, $message = '')
    493. 

  493.     {
    494. 

  494.         $valid = isset($value[0]);
    495. 

  495. 

  496.         if ($valid) {
    497. 

  497.             $locale = setlocale(LC_CTYPE, 0);
    498. 

  498.             setlocale(LC_CTYPE, 'C');
    499. 

  499.             $valid = ctype_alpha($value[0]);
    500. 

  500.             setlocale(LC_CTYPE, $locale);
    501. 

  501.         }
    502. 

  502. 

  503.         if (!$valid) {
    504. 

  504.             throw new InvalidArgumentException(sprintf(
    505. 

  505.                 $message ?: 'Expected a value to start with a letter. Got: %s',
    506. 

  506.                 self::valueToString($value)
    507. 

  507.             ));
    508. 

  508.         }
    509. 

  509.     }
    510. 

  510. 

  511.     public static function endsWith($value, $suffix, $message = '')
    512. 

  512.     {
    513. 

  513.         if ($suffix !== substr($value, -self::strlen($suffix))) {
    514. 

  514.             throw new InvalidArgumentException(sprintf(
    515. 

  515.                 $message ?: 'Expected a value to end with %2$s. Got: %s',
    516. 

  516.                 self::valueToString($value),
    517. 

  517.                 self::valueToString($suffix)
    518. 

  518.             ));
    519. 

  519.         }
    520. 

  520.     }
    521. 

  521. 

  522.     public static function regex($value, $pattern, $message = '')
    523. 

  523.     {
    524. 

  524.         if (!preg_match($pattern, $value)) {
    525. 

  525.             throw new InvalidArgumentException(sprintf(
    526. 

  526.                 $message ?: 'The value %s does not match the expected pattern.',
    527. 

  527.                 self::valueToString($value)
    528. 

  528.             ));
    529. 

  529.         }
    530. 

  530.     }
    531. 

  531. 

  532.     public static function alpha($value, $message = '')
    533. 

  533.     {
    534. 

  534.         $locale = setlocale(LC_CTYPE, 0);
    535. 

  535.         setlocale(LC_CTYPE, 'C');
    536. 

  536.         $valid = !ctype_alpha($value);
    537. 

  537.         setlocale(LC_CTYPE, $locale);
    538. 

  538. 

  539.         if ($valid) {
    540. 

  540.             throw new InvalidArgumentException(sprintf(
    541. 

  541.                 $message ?: 'Expected a value to contain only letters. Got: %s',
    542. 

  542.                 self::valueToString($value)
    543. 

  543.             ));
    544. 

  544.         }
    545. 

  545.     }
    546. 

  546. 

  547.     public static function digits($value, $message = '')
    548. 

  548.     {
    549. 

  549.         $locale = setlocale(LC_CTYPE, 0);
    550. 

  550.         setlocale(LC_CTYPE, 'C');
    551. 

  551.         $valid = !ctype_digit($value);
    552. 

  552.         setlocale(LC_CTYPE, $locale);
    553. 

  553. 

  554.         if ($valid) {
    555. 

  555.             throw new InvalidArgumentException(sprintf(
    556. 

  556.                 $message ?: 'Expected a value to contain digits only. Got: %s',
    557. 

  557.                 self::valueToString($value)
    558. 

  558.             ));
    559. 

  559.         }
    560. 

  560.     }
    561. 

  561. 

  562.     public static function alnum($value, $message = '')
    563. 

  563.     {
    564. 

  564.         $locale = setlocale(LC_CTYPE, 0);
    565. 

  565.         setlocale(LC_CTYPE, 'C');
    566. 

  566.         $valid = !ctype_alnum($value);
    567. 

  567.         setlocale(LC_CTYPE, $locale);
    568. 

  568. 

  569.         if ($valid) {
    570. 

  570.             throw new InvalidArgumentException(sprintf(
    571. 

  571.                 $message ?: 'Expected a value to contain letters and digits only. Got: %s',
    572. 

  572.                 self::valueToString($value)
    573. 

  573.             ));
    574. 

  574.         }
    575. 

  575.     }
    576. 

  576. 

  577.     public static function lower($value, $message = '')
    578. 

  578.     {
    579. 

  579.         $locale = setlocale(LC_CTYPE, 0);
    580. 

  580.         setlocale(LC_CTYPE, 'C');
    581. 

  581.         $valid = !ctype_lower($value);
    582. 

  582.         setlocale(LC_CTYPE, $locale);
    583. 

  583. 

  584.         if ($valid) {
    585. 

  585.             throw new InvalidArgumentException(sprintf(
    586. 

  586.                 $message ?: 'Expected a value to contain lowercase characters only. Got: %s',
    587. 

  587.                 self::valueToString($value)
    588. 

  588.             ));
    589. 

  589.         }
    590. 

  590.     }
    591. 

  591. 

  592.     public static function upper($value, $message = '')
    593. 

  593.     {
    594. 

  594.         $locale = setlocale(LC_CTYPE, 0);
    595. 

  595.         setlocale(LC_CTYPE, 'C');
    596. 

  596.         $valid = !ctype_upper($value);
    597. 

  597.         setlocale(LC_CTYPE, $locale);
    598. 

  598. 

  599.         if ($valid) {
    600. 

  600.             throw new InvalidArgumentException(sprintf(
    601. 

  601.                 $message ?: 'Expected a value to contain uppercase characters only. Got: %s',
    602. 

  602.                 self::valueToString($value)
    603. 

  603.             ));
    604. 

  604.         }
    605. 

  605.     }
    606. 

  606. 

  607.     public static function length($value, $length, $message = '')
    608. 

  608.     {
    609. 

  609.         if ($length !== self::strlen($value)) {
    610. 

  610.             throw new InvalidArgumentException(sprintf(
    611. 

  611.                 $message ?: 'Expected a value to contain %2$s characters. Got: %s',
    612. 

  612.                 self::valueToString($value),
    613. 

  613.                 $length
    614. 

  614.             ));
    615. 

  615.         }
    616. 

  616.     }
    617. 

  617. 

  618.     public static function minLength($value, $min, $message = '')
    619. 

  619.     {
    620. 

  620.         if (self::strlen($value) < $min) {
    621. 

  621.             throw new InvalidArgumentException(sprintf(
    622. 

  622.                 $message ?: 'Expected a value to contain at least %2$s characters. Got: %s',
    623. 

  623.                 self::valueToString($value),
    624. 

  624.                 $min
    625. 

  625.             ));
    626. 

  626.         }
    627. 

  627.     }
    628. 

  628. 

  629.     public static function maxLength($value, $max, $message = '')
    630. 

  630.     {
    631. 

  631.         if (self::strlen($value) > $max) {
    632. 

  632.             throw new InvalidArgumentException(sprintf(
    633. 

  633.                 $message ?: 'Expected a value to contain at most %2$s characters. Got: %s',
    634. 

  634.                 self::valueToString($value),
    635. 

  635.                 $max
    636. 

  636.             ));
    637. 

  637.         }
    638. 

  638.     }
    639. 

  639. 

  640.     public static function lengthBetween($value, $min, $max, $message = '')
    641. 

  641.     {
    642. 

  642.         $length = self::strlen($value);
    643. 

  643. 

  644.         if ($length < $min || $length > $max) {
    645. 

  645.             throw new InvalidArgumentException(sprintf(
    646. 

  646.                 $message ?: 'Expected a value to contain between %2$s and %3$s characters. Got: %s',
    647. 

  647.                 self::valueToString($value),
    648. 

  648.                 $min,
    649. 

  649.                 $max
    650. 

  650.             ));
    651. 

  651.         }
    652. 

  652.     }
    653. 

  653. 

  654.     public static function fileExists($value, $message = '')
    655. 

  655.     {
    656. 

  656.         self::string($value);
    657. 

  657. 

  658.         if (!file_exists($value)) {
    659. 

  659.             throw new InvalidArgumentException(sprintf(
    660. 

  660.                 $message ?: 'The file %s does not exist.',
    661. 

  661.                 self::valueToString($value)
    662. 

  662.             ));
    663. 

  663.         }
    664. 

  664.     }
    665. 

  665. 

  666.     public static function file($value, $message = '')
    667. 

  667.     {
    668. 

  668.         self::fileExists($value, $message);
    669. 

  669. 

  670.         if (!is_file($value)) {
    671. 

  671.             throw new InvalidArgumentException(sprintf(
    672. 

  672.                 $message ?: 'The path %s is not a file.',
    673. 

  673.                 self::valueToString($value)
    674. 

  674.             ));
    675. 

  675.         }
    676. 

  676.     }
    677. 

  677. 

  678.     public static function directory($value, $message = '')
    679. 

  679.     {
    680. 

  680.         self::fileExists($value, $message);
    681. 

  681. 

  682.         if (!is_dir($value)) {
    683. 

  683.             throw new InvalidArgumentException(sprintf(
    684. 

  684.                 $message ?: 'The path %s is no directory.',
    685. 

  685.                 self::valueToString($value)
    686. 

  686.             ));
    687. 

  687.         }
    688. 

  688.     }
    689. 

  689. 

  690.     public static function readable($value, $message = '')
    691. 

  691.     {
    692. 

  692.         if (!is_readable($value)) {
    693. 

  693.             throw new InvalidArgumentException(sprintf(
    694. 

  694.                 $message ?: 'The path %s is not readable.',
    695. 

  695.                 self::valueToString($value)
    696. 

  696.             ));
    697. 

  697.         }
    698. 

  698.     }
    699. 

  699. 

  700.     public static function writable($value, $message = '')
    701. 

  701.     {
    702. 

  702.         if (!is_writable($value)) {
    703. 

  703.             throw new InvalidArgumentException(sprintf(
    704. 

  704.                 $message ?: 'The path %s is not writable.',
    705. 

  705.                 self::valueToString($value)
    706. 

  706.             ));
    707. 

  707.         }
    708. 

  708.     }
    709. 

  709. 

  710.     public static function classExists($value, $message = '')
    711. 

  711.     {
    712. 

  712.         if (!class_exists($value)) {
    713. 

  713.             throw new InvalidArgumentException(sprintf(
    714. 

  714.                 $message ?: 'Expected an existing class name. Got: %s',
    715. 

  715.                 self::valueToString($value)
    716. 

  716.             ));
    717. 

  717.         }
    718. 

  718.     }
    719. 

  719. 

  720.     public static function subclassOf($value, $class, $message = '')
    721. 

  721.     {
    722. 

  722.         if (!is_subclass_of($value, $class)) {
    723. 

  723.             throw new InvalidArgumentException(sprintf(
    724. 

  724.                 $message ?: 'Expected a sub-class of %2$s. Got: %s',
    725. 

  725.                 self::valueToString($value),
    726. 

  726.                 self::valueToString($class)
    727. 

  727.             ));
    728. 

  728.         }
    729. 

  729.     }
    730. 

  730. 

  731.     public static function implementsInterface($value, $interface, $message = '')
    732. 

  732.     {
    733. 

  733.         if (!in_array($interface, class_implements($value))) {
    734. 

  734.             throw new InvalidArgumentException(sprintf(
    735. 

  735.                 $message ?: 'Expected an implementation of %2$s. Got: %s',
    736. 

  736.                 self::valueToString($value),
    737. 

  737.                 self::valueToString($interface)
    738. 

  738.             ));
    739. 

  739.         }
    740. 

  740.     }
    741. 

  741. 

  742.     public static function propertyExists($classOrObject, $property, $message = '')
    743. 

  743.     {
    744. 

  744.         if (!property_exists($classOrObject, $property)) {
    745. 

  745.             throw new InvalidArgumentException(sprintf(
    746. 

  746.                 $message ?: 'Expected the property %s to exist.',
    747. 

  747.                 self::valueToString($property)
    748. 

  748.             ));
    749. 

  749.         }
    750. 

  750.     }
    751. 

  751. 

  752.     public static function propertyNotExists($classOrObject, $property, $message = '')
    753. 

  753.     {
    754. 

  754.         if (property_exists($classOrObject, $property)) {
    755. 

  755.             throw new InvalidArgumentException(sprintf(
    756. 

  756.                 $message ?: 'Expected the property %s to not exist.',
    757. 

  757.                 self::valueToString($property)
    758. 

  758.             ));
    759. 

  759.         }
    760. 

  760.     }
    761. 

  761. 

  762.     public static function methodExists($classOrObject, $method, $message = '')
    763. 

  763.     {
    764. 

  764.         if (!method_exists($classOrObject, $method)) {
    765. 

  765.             throw new InvalidArgumentException(sprintf(
    766. 

  766.                 $message ?: 'Expected the method %s to exist.',
    767. 

  767.                 self::valueToString($method)
    768. 

  768.             ));
    769. 

  769.         }
    770. 

  770.     }
    771. 

  771. 

  772.     public static function methodNotExists($classOrObject, $method, $message = '')
    773. 

  773.     {
    774. 

  774.         if (method_exists($classOrObject, $method)) {
    775. 

  775.             throw new InvalidArgumentException(sprintf(
    776. 

  776.                 $message ?: 'Expected the method %s to not exist.',
    777. 

  777.                 self::valueToString($method)
    778. 

  778.             ));
    779. 

  779.         }
    780. 

  780.     }
    781. 

  781. 

  782.     public static function keyExists($array, $key, $message = '')
    783. 

  783.     {
    784. 

  784.         if (!array_key_exists($key, $array)) {
    785. 

  785.             throw new InvalidArgumentException(sprintf(
    786. 

  786.                 $message ?: 'Expected the key %s to exist.',
    787. 

  787.                 self::valueToString($key)
    788. 

  788.             ));
    789. 

  789.         }
    790. 

  790.     }
    791. 

  791. 

  792.     public static function keyNotExists($array, $key, $message = '')
    793. 

  793.     {
    794. 

  794.         if (array_key_exists($key, $array)) {
    795. 

  795.             throw new InvalidArgumentException(sprintf(
    796. 

  796.                 $message ?: 'Expected the key %s to not exist.',
    797. 

  797.                 self::valueToString($key)
    798. 

  798.             ));
    799. 

  799.         }
    800. 

  800.     }
    801. 

  801. 

  802.     public static function uuid($value, $message = '')
    803. 

  803.     {
    804. 

  804.         $value = str_replace(array('urn:', 'uuid:', '{', '}'), '', $value);
    805. 

  805. 

  806.         // The nil UUID is special form of UUID that is specified to have all
    807. 

  807.         // 128 bits set to zero.
    808. 

  808.         if ('00000000-0000-0000-0000-000000000000' === $value) {
    809. 

  809.             return;
    810. 

  810.         }
    811. 

  811. 

  812.         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)) {
    813. 

  813.             throw new InvalidArgumentException(sprintf(
    814. 

  814.                 $message ?: 'Value "%s" is not a valid UUID.',
    815. 

  815.                 self::valueToString($value)
    816. 

  816.             ));
    817. 

  817.         }
    818. 

  818.     }
    819. 

  819. 

  820.     public static function __callStatic($name, $arguments)
    821. 

  821.     {
    822. 

  822.         if ('nullOr' === substr($name, 0, 6)) {
    823. 

  823.             if (null !== $arguments[0]) {
    824. 

  824.                 $method = lcfirst(substr($name, 6));
    825. 

  825.                 call_user_func_array(array('static', $method), $arguments);
    826. 

  826.             }
    827. 

  827. 

  828.             return;
    829. 

  829.         }
    830. 

  830. 

  831.         if ('all' === substr($name, 0, 3)) {
    832. 

  832.             self::isTraversable($arguments[0]);
    833. 

  833. 

  834.             $method = lcfirst(substr($name, 3));
    835. 

  835.             $args = $arguments;
    836. 

  836. 

  837.             foreach ($arguments[0] as $entry) {
    838. 

  838.                 $args[0] = $entry;
    839. 

  839. 

  840.                 call_user_func_array(array('static', $method), $args);
    841. 

  841.             }
    842. 

  842. 

  843.             return;
    844. 

  844.         }
    845. 

  845. 

  846.         throw new BadMethodCallException('No such method: '.$name);
    847. 

  847.     }
    848. 

  848. 

  849.     protected static function valueToString($value)
    850. 

  850.     {
    851. 

  851.         if (null === $value) {
    852. 

  852.             return 'null';
    853. 

  853.         }
    854. 

  854. 

  855.         if (true === $value) {
    856. 

  856.             return 'true';
    857. 

  857.         }
    858. 

  858. 

  859.         if (false === $value) {
    860. 

  860.             return 'false';
    861. 

  861.         }
    862. 

  862. 

  863.         if (is_array($value)) {
    864. 

  864.             return 'array';
    865. 

  865.         }
    866. 

  866. 

  867.         if (is_object($value)) {
    868. 

  868.             return get_class($value);
    869. 

  869.         }
    870. 

  870. 

  871.         if (is_resource($value)) {
    872. 

  872.             return 'resource';
    873. 

  873.         }
    874. 

  874. 

  875.         if (is_string($value)) {
    876. 

  876.             return '"'.$value.'"';
    877. 

  877.         }
    878. 

  878. 

  879.         return (string) $value;
    880. 

  880.     }
    881. 

  881. 

  882.     protected static function typeToString($value)
    883. 

  883.     {
    884. 

  884.         return is_object($value) ? get_class($value) : gettype($value);
    885. 

  885.     }
    886. 

  886. 

  887.     protected static function strlen($value)
    888. 

  888.     {
    889. 

  889.         if (!function_exists('mb_detect_encoding')) {
    890. 

  890.             return strlen($value);
    891. 

  891.         }
    892. 

  892. 

  893.         if (false === $encoding = mb_detect_encoding($value)) {
    894. 

  894.             return strlen($value);
    895. 

  895.         }
    896. 

  896. 

  897.         return mb_strwidth($value, $encoding);
    898. 

  898.     }
    899. 

  899. 

  900.     private function __construct()
    901. 

  901.     {
    902. 

  902.     }
    903. 

  903. }
    904.