ar_JO
1 year ago
ar_SA
1 year ago
at_AT
1 year ago
bg_BG
1 year ago
bn_BD
1 year ago
cs_CZ
1 year ago
da_DK
1 year ago
de_AT
1 year ago
de_CH
1 year ago
de_DE
1 year ago
el_CY
1 year ago
el_GR
1 year ago
en_AU
1 year ago
en_CA
1 year ago
en_GB
1 year ago
en_HK
1 year ago
en_IN
1 year ago
en_NG
1 year ago
en_NZ
1 year ago
en_PH
1 year ago
en_SG
1 year ago
en_UG
1 year ago
en_US
1 year ago
en_ZA
1 year ago
es_AR
1 year ago
es_ES
1 year ago
es_PE
1 year ago
es_VE
1 year ago
et_EE
1 year ago
fa_IR
1 year ago
fi_FI
1 year ago
fr_BE
1 year ago
fr_CA
1 year ago
fr_CH
1 year ago
fr_FR
1 year ago
he_IL
1 year ago
hr_HR
1 year ago
hu_HU
1 year ago
hy_AM
1 year ago
id_ID
1 year ago
is_IS
1 year ago
it_CH
1 year ago
it_IT
1 year ago
ja_JP
1 year ago
ka_GE
1 year ago
kk_KZ
1 year ago
ko_KR
1 year ago
lt_LT
1 year ago
lv_LV
1 year ago
me_ME
1 year ago
mn_MN
1 year ago
ms_MY
1 year ago
nb_NO
1 year ago
ne_NP
1 year ago
nl_BE
1 year ago
nl_NL
1 year ago
pl_PL
1 year ago
pt_BR
1 year ago
pt_PT
1 year ago
ro_MD
1 year ago
ro_RO
1 year ago
ru_RU
1 year ago
sk_SK
1 year ago
sl_SI
1 year ago
sr_Cyrl_RS
1 year ago
sr_Latn_RS
1 year ago
sr_RS
1 year ago
sv_SE
1 year ago
th_TH
1 year ago
tr_TR
1 year ago
uk_UA
1 year ago
vi_VN
1 year ago
zh_CN
1 year ago
zh_TW
1 year ago
Address.php
1 year ago
Barcode.php
1 year ago
Base.php
1 year ago
Biased.php
1 year ago
Color.php
1 year ago
Company.php
1 year ago
DateTime.php
1 year ago
File.php
1 year ago
HtmlLorem.php
1 year ago
Image.php
1 year ago
Internet.php
1 year ago
Lorem.php
1 year ago
Miscellaneous.php
1 year ago
Payment.php
1 year ago
Person.php
1 year ago
PhoneNumber.php
1 year ago
Text.php
1 year ago
UserAgent.php
1 year ago
Uuid.php
1 year ago
Base.php
613 lines
| 1 | <?php |
| 2 | |
| 3 | namespace Faker\Provider; |
| 4 | |
| 5 | use Faker\Generator; |
| 6 | use Faker\DefaultGenerator; |
| 7 | use Faker\UniqueGenerator; |
| 8 | use Faker\ValidGenerator; |
| 9 | |
| 10 | class Base |
| 11 | { |
| 12 | /** |
| 13 | * @var \Faker\Generator |
| 14 | */ |
| 15 | protected $generator; |
| 16 | |
| 17 | /** |
| 18 | * @var \Faker\UniqueGenerator |
| 19 | */ |
| 20 | protected $unique; |
| 21 | |
| 22 | /** |
| 23 | * @param \Faker\Generator $generator |
| 24 | */ |
| 25 | public function __construct(Generator $generator) |
| 26 | { |
| 27 | $this->generator = $generator; |
| 28 | } |
| 29 | |
| 30 | /** |
| 31 | * Returns a random number between 0 and 9 |
| 32 | * |
| 33 | * @return integer |
| 34 | */ |
| 35 | public static function randomDigit() |
| 36 | { |
| 37 | return mt_rand(0, 9); |
| 38 | } |
| 39 | |
| 40 | /** |
| 41 | * Returns a random number between 1 and 9 |
| 42 | * |
| 43 | * @return integer |
| 44 | */ |
| 45 | public static function randomDigitNotNull() |
| 46 | { |
| 47 | return mt_rand(1, 9); |
| 48 | } |
| 49 | |
| 50 | /** |
| 51 | * Generates a random digit, which cannot be $except |
| 52 | * |
| 53 | * @param int $except |
| 54 | * @return int |
| 55 | */ |
| 56 | public static function randomDigitNot($except) |
| 57 | { |
| 58 | $result = self::numberBetween(0, 8); |
| 59 | if ($result >= $except) { |
| 60 | $result++; |
| 61 | } |
| 62 | return $result; |
| 63 | } |
| 64 | |
| 65 | /** |
| 66 | * Returns a random integer with 0 to $nbDigits digits. |
| 67 | * |
| 68 | * The maximum value returned is mt_getrandmax() |
| 69 | * |
| 70 | * @param integer $nbDigits Defaults to a random number between 1 and 9 |
| 71 | * @param boolean $strict Whether the returned number should have exactly $nbDigits |
| 72 | * @example 79907610 |
| 73 | * |
| 74 | * @return integer |
| 75 | */ |
| 76 | public static function randomNumber($nbDigits = null, $strict = false) |
| 77 | { |
| 78 | if (!is_bool($strict)) { |
| 79 | throw new \InvalidArgumentException('randomNumber() generates numbers of fixed width. To generate numbers between two boundaries, use numberBetween() instead.'); |
| 80 | } |
| 81 | if (null === $nbDigits) { |
| 82 | $nbDigits = static::randomDigitNotNull(); |
| 83 | } |
| 84 | $max = pow(10, $nbDigits) - 1; |
| 85 | if ($max > mt_getrandmax()) { |
| 86 | throw new \InvalidArgumentException('randomNumber() can only generate numbers up to mt_getrandmax()'); |
| 87 | } |
| 88 | if ($strict) { |
| 89 | return mt_rand(pow(10, $nbDigits - 1), $max); |
| 90 | } |
| 91 | |
| 92 | return mt_rand(0, $max); |
| 93 | } |
| 94 | |
| 95 | /** |
| 96 | * Return a random float number |
| 97 | * |
| 98 | * @param int $nbMaxDecimals |
| 99 | * @param int|float $min |
| 100 | * @param int|float $max |
| 101 | * @example 48.8932 |
| 102 | * |
| 103 | * @return float |
| 104 | */ |
| 105 | public static function randomFloat($nbMaxDecimals = null, $min = 0, $max = null) |
| 106 | { |
| 107 | if (null === $nbMaxDecimals) { |
| 108 | $nbMaxDecimals = static::randomDigit(); |
| 109 | } |
| 110 | |
| 111 | if (null === $max) { |
| 112 | $max = static::randomNumber(); |
| 113 | if ($min > $max) { |
| 114 | $max = $min; |
| 115 | } |
| 116 | } |
| 117 | |
| 118 | if ($min > $max) { |
| 119 | $tmp = $min; |
| 120 | $min = $max; |
| 121 | $max = $tmp; |
| 122 | } |
| 123 | |
| 124 | return round($min + mt_rand() / mt_getrandmax() * ($max - $min), $nbMaxDecimals); |
| 125 | } |
| 126 | |
| 127 | /** |
| 128 | * Returns a random number between $int1 and $int2 (any order) |
| 129 | * |
| 130 | * @param integer $int1 default to 0 |
| 131 | * @param integer $int2 defaults to 32 bit max integer, ie 2147483647 |
| 132 | * @example 79907610 |
| 133 | * |
| 134 | * @return integer |
| 135 | */ |
| 136 | public static function numberBetween($int1 = 0, $int2 = 2147483647) |
| 137 | { |
| 138 | $min = $int1 < $int2 ? $int1 : $int2; |
| 139 | $max = $int1 < $int2 ? $int2 : $int1; |
| 140 | return mt_rand($min, $max); |
| 141 | } |
| 142 | |
| 143 | /** |
| 144 | * Returns the passed value |
| 145 | * |
| 146 | * @param mixed $value |
| 147 | * |
| 148 | * @return mixed |
| 149 | */ |
| 150 | public static function passthrough($value) |
| 151 | { |
| 152 | return $value; |
| 153 | } |
| 154 | |
| 155 | /** |
| 156 | * Returns a random letter from a to z |
| 157 | * |
| 158 | * @return string |
| 159 | */ |
| 160 | public static function randomLetter() |
| 161 | { |
| 162 | return chr(mt_rand(97, 122)); |
| 163 | } |
| 164 | |
| 165 | /** |
| 166 | * Returns a random ASCII character (excluding accents and special chars) |
| 167 | */ |
| 168 | public static function randomAscii() |
| 169 | { |
| 170 | return chr(mt_rand(33, 126)); |
| 171 | } |
| 172 | |
| 173 | /** |
| 174 | * Returns randomly ordered subsequence of $count elements from a provided array |
| 175 | * |
| 176 | * @param array $array Array to take elements from. Defaults to a-c |
| 177 | * @param integer $count Number of elements to take. |
| 178 | * @param boolean $allowDuplicates Allow elements to be picked several times. Defaults to false |
| 179 | * @throws \LengthException When requesting more elements than provided |
| 180 | * |
| 181 | * @return array New array with $count elements from $array |
| 182 | */ |
| 183 | public static function randomElements($array = array('a', 'b', 'c'), $count = 1, $allowDuplicates = false) |
| 184 | { |
| 185 | $traversables = array(); |
| 186 | |
| 187 | if ($array instanceof \Traversable) { |
| 188 | foreach ($array as $element) { |
| 189 | $traversables[] = $element; |
| 190 | } |
| 191 | } |
| 192 | |
| 193 | $arr = count($traversables) ? $traversables : $array; |
| 194 | |
| 195 | $allKeys = array_keys($arr); |
| 196 | $numKeys = count($allKeys); |
| 197 | |
| 198 | if (!$allowDuplicates && $numKeys < $count) { |
| 199 | throw new \LengthException(sprintf('Cannot get %d elements, only %d in array', $count, $numKeys)); |
| 200 | } |
| 201 | |
| 202 | $highKey = $numKeys - 1; |
| 203 | $keys = $elements = array(); |
| 204 | $numElements = 0; |
| 205 | |
| 206 | while ($numElements < $count) { |
| 207 | $num = mt_rand(0, $highKey); |
| 208 | |
| 209 | if (!$allowDuplicates) { |
| 210 | if (isset($keys[$num])) { |
| 211 | continue; |
| 212 | } |
| 213 | $keys[$num] = true; |
| 214 | } |
| 215 | |
| 216 | $elements[] = $arr[$allKeys[$num]]; |
| 217 | $numElements++; |
| 218 | } |
| 219 | |
| 220 | return $elements; |
| 221 | } |
| 222 | |
| 223 | /** |
| 224 | * Returns a random element from a passed array |
| 225 | * |
| 226 | * @param array $array |
| 227 | * @return mixed |
| 228 | */ |
| 229 | public static function randomElement($array = array('a', 'b', 'c')) |
| 230 | { |
| 231 | if (!$array || ($array instanceof \Traversable && !count($array))) { |
| 232 | return null; |
| 233 | } |
| 234 | $elements = static::randomElements($array, 1); |
| 235 | |
| 236 | return $elements[0]; |
| 237 | } |
| 238 | |
| 239 | /** |
| 240 | * Returns a random key from a passed associative array |
| 241 | * |
| 242 | * @param array $array |
| 243 | * @return int|string|null |
| 244 | */ |
| 245 | public static function randomKey($array = array()) |
| 246 | { |
| 247 | if (!$array) { |
| 248 | return null; |
| 249 | } |
| 250 | $keys = array_keys($array); |
| 251 | $key = $keys[mt_rand(0, count($keys) - 1)]; |
| 252 | |
| 253 | return $key; |
| 254 | } |
| 255 | |
| 256 | /** |
| 257 | * Returns a shuffled version of the argument. |
| 258 | * |
| 259 | * This function accepts either an array, or a string. |
| 260 | * |
| 261 | * @example $faker->shuffle([1, 2, 3]); // [2, 1, 3] |
| 262 | * @example $faker->shuffle('hello, world'); // 'rlo,h eold!lw' |
| 263 | * |
| 264 | * @see shuffleArray() |
| 265 | * @see shuffleString() |
| 266 | * |
| 267 | * @param array|string $arg The set to shuffle |
| 268 | * @return array|string The shuffled set |
| 269 | */ |
| 270 | public static function shuffle($arg = '') |
| 271 | { |
| 272 | if (is_array($arg)) { |
| 273 | return static::shuffleArray($arg); |
| 274 | } |
| 275 | if (is_string($arg)) { |
| 276 | return static::shuffleString($arg); |
| 277 | } |
| 278 | throw new \InvalidArgumentException('shuffle() only supports strings or arrays'); |
| 279 | } |
| 280 | |
| 281 | /** |
| 282 | * Returns a shuffled version of the array. |
| 283 | * |
| 284 | * This function does not mutate the original array. It uses the |
| 285 | * Fisher–Yates algorithm, which is unbiased, together with a Mersenne |
| 286 | * twister random generator. This function is therefore more random than |
| 287 | * PHP's shuffle() function, and it is seedable. |
| 288 | * |
| 289 | * @link http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle |
| 290 | * |
| 291 | * @example $faker->shuffleArray([1, 2, 3]); // [2, 1, 3] |
| 292 | * |
| 293 | * @param array $array The set to shuffle |
| 294 | * @return array The shuffled set |
| 295 | */ |
| 296 | public static function shuffleArray($array = array()) |
| 297 | { |
| 298 | $shuffledArray = array(); |
| 299 | $i = 0; |
| 300 | reset($array); |
| 301 | foreach ($array as $key => $value) { |
| 302 | if ($i == 0) { |
| 303 | $j = 0; |
| 304 | } else { |
| 305 | $j = mt_rand(0, $i); |
| 306 | } |
| 307 | if ($j == $i) { |
| 308 | $shuffledArray[]= $value; |
| 309 | } else { |
| 310 | $shuffledArray[]= $shuffledArray[$j]; |
| 311 | $shuffledArray[$j] = $value; |
| 312 | } |
| 313 | $i++; |
| 314 | } |
| 315 | return $shuffledArray; |
| 316 | } |
| 317 | |
| 318 | /** |
| 319 | * Returns a shuffled version of the string. |
| 320 | * |
| 321 | * This function does not mutate the original string. It uses the |
| 322 | * Fisher–Yates algorithm, which is unbiased, together with a Mersenne |
| 323 | * twister random generator. This function is therefore more random than |
| 324 | * PHP's shuffle() function, and it is seedable. Additionally, it is |
| 325 | * UTF8 safe if the mb extension is available. |
| 326 | * |
| 327 | * @link http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle |
| 328 | * |
| 329 | * @example $faker->shuffleString('hello, world'); // 'rlo,h eold!lw' |
| 330 | * |
| 331 | * @param string $string The set to shuffle |
| 332 | * @param string $encoding The string encoding (defaults to UTF-8) |
| 333 | * @return string The shuffled set |
| 334 | */ |
| 335 | public static function shuffleString($string = '', $encoding = 'UTF-8') |
| 336 | { |
| 337 | if (function_exists('mb_strlen')) { |
| 338 | // UTF8-safe str_split() |
| 339 | $array = array(); |
| 340 | $strlen = mb_strlen($string, $encoding); |
| 341 | for ($i = 0; $i < $strlen; $i++) { |
| 342 | $array []= mb_substr($string, $i, 1, $encoding); |
| 343 | } |
| 344 | } else { |
| 345 | $array = str_split($string, 1); |
| 346 | } |
| 347 | return implode('', static::shuffleArray($array)); |
| 348 | } |
| 349 | |
| 350 | private static function replaceWildcard($string, $wildcard = '#', $callback = 'static::randomDigit') |
| 351 | { |
| 352 | if (($pos = strpos($string, $wildcard)) === false) { |
| 353 | return $string; |
| 354 | } |
| 355 | for ($i = $pos, $last = strrpos($string, $wildcard, $pos) + 1; $i < $last; $i++) { |
| 356 | if ($string[$i] === $wildcard) { |
| 357 | $string[$i] = call_user_func($callback); |
| 358 | } |
| 359 | } |
| 360 | return $string; |
| 361 | } |
| 362 | |
| 363 | /** |
| 364 | * Replaces all hash sign ('#') occurrences with a random number |
| 365 | * Replaces all percentage sign ('%') occurrences with a not null number |
| 366 | * |
| 367 | * @param string $string String that needs to bet parsed |
| 368 | * @return string |
| 369 | */ |
| 370 | public static function numerify($string = '###') |
| 371 | { |
| 372 | // instead of using randomDigit() several times, which is slow, |
| 373 | // count the number of hashes and generate once a large number |
| 374 | $toReplace = array(); |
| 375 | if (($pos = strpos($string, '#')) !== false) { |
| 376 | for ($i = $pos, $last = strrpos($string, '#', $pos) + 1; $i < $last; $i++) { |
| 377 | if ($string[$i] === '#') { |
| 378 | $toReplace[] = $i; |
| 379 | } |
| 380 | } |
| 381 | } |
| 382 | if ($nbReplacements = count($toReplace)) { |
| 383 | $maxAtOnce = strlen((string) mt_getrandmax()) - 1; |
| 384 | $numbers = ''; |
| 385 | $i = 0; |
| 386 | while ($i < $nbReplacements) { |
| 387 | $size = min($nbReplacements - $i, $maxAtOnce); |
| 388 | $numbers .= str_pad(static::randomNumber($size), $size, '0', STR_PAD_LEFT); |
| 389 | $i += $size; |
| 390 | } |
| 391 | for ($i = 0; $i < $nbReplacements; $i++) { |
| 392 | $string[$toReplace[$i]] = $numbers[$i]; |
| 393 | } |
| 394 | } |
| 395 | $string = self::replaceWildcard($string, '%', 'static::randomDigitNotNull'); |
| 396 | |
| 397 | return $string; |
| 398 | } |
| 399 | |
| 400 | /** |
| 401 | * Replaces all question mark ('?') occurrences with a random letter |
| 402 | * |
| 403 | * @param string $string String that needs to bet parsed |
| 404 | * @return string |
| 405 | */ |
| 406 | public static function lexify($string = '????') |
| 407 | { |
| 408 | return self::replaceWildcard($string, '?', 'static::randomLetter'); |
| 409 | } |
| 410 | |
| 411 | /** |
| 412 | * Replaces hash signs ('#') and question marks ('?') with random numbers and letters |
| 413 | * An asterisk ('*') is replaced with either a random number or a random letter |
| 414 | * |
| 415 | * @param string $string String that needs to bet parsed |
| 416 | * @return string |
| 417 | */ |
| 418 | public static function bothify($string = '## ??') |
| 419 | { |
| 420 | $string = self::replaceWildcard($string, '*', function () { |
| 421 | return mt_rand(0, 1) ? '#' : '?'; |
| 422 | }); |
| 423 | return static::lexify(static::numerify($string)); |
| 424 | } |
| 425 | |
| 426 | /** |
| 427 | * Replaces * signs with random numbers and letters and special characters |
| 428 | * |
| 429 | * @example $faker->asciify(''********'); // "s5'G!uC3" |
| 430 | * |
| 431 | * @param string $string String that needs to bet parsed |
| 432 | * @return string |
| 433 | */ |
| 434 | public static function asciify($string = '****') |
| 435 | { |
| 436 | return preg_replace_callback('/\*/u', 'static::randomAscii', $string); |
| 437 | } |
| 438 | |
| 439 | /** |
| 440 | * Transforms a basic regular expression into a random string satisfying the expression. |
| 441 | * |
| 442 | * @example $faker->regexify('[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}'); // sm0@y8k96a.ej |
| 443 | * |
| 444 | * Regex delimiters '/.../' and begin/end markers '^...$' are ignored. |
| 445 | * |
| 446 | * Only supports a small subset of the regex syntax. For instance, |
| 447 | * unicode, negated classes, unbounded ranges, subpatterns, back references, |
| 448 | * assertions, recursive patterns, and comments are not supported. Escaping |
| 449 | * support is extremely fragile. |
| 450 | * |
| 451 | * This method is also VERY slow. Use it only when no other formatter |
| 452 | * can generate the fake data you want. For instance, prefer calling |
| 453 | * `$faker->email` rather than `regexify` with the previous regular |
| 454 | * expression. |
| 455 | * |
| 456 | * Also note than `bothify` can probably do most of what this method does, |
| 457 | * but much faster. For instance, for a dummy email generation, try |
| 458 | * `$faker->bothify('?????????@???.???')`. |
| 459 | * |
| 460 | * @see https://github.com/icomefromthenet/ReverseRegex for a more robust implementation |
| 461 | * |
| 462 | * @param string $regex A regular expression (delimiters are optional) |
| 463 | * @return string |
| 464 | */ |
| 465 | public static function regexify($regex = '') |
| 466 | { |
| 467 | // ditch the anchors |
| 468 | $regex = preg_replace('/^\/?\^?/', '', $regex); |
| 469 | $regex = preg_replace('/\$?\/?$/', '', $regex); |
| 470 | // All {2} become {2,2} |
| 471 | $regex = preg_replace('/\{(\d+)\}/', '{\1,\1}', $regex); |
| 472 | // Single-letter quantifiers (?, *, +) become bracket quantifiers ({0,1}, {0,rand}, {1, rand}) |
| 473 | $regex = preg_replace('/(?<!\\\)\?/', '{0,1}', $regex); |
| 474 | $regex = preg_replace('/(?<!\\\)\*/', '{0,' . static::randomDigitNotNull() . '}', $regex); |
| 475 | $regex = preg_replace('/(?<!\\\)\+/', '{1,' . static::randomDigitNotNull() . '}', $regex); |
| 476 | // [12]{1,2} becomes [12] or [12][12] |
| 477 | $regex = preg_replace_callback('/(\[[^\]]+\])\{(\d+),(\d+)\}/', function ($matches) { |
| 478 | return str_repeat($matches[1], Base::randomElement(range($matches[2], $matches[3]))); |
| 479 | }, $regex); |
| 480 | // (12|34){1,2} becomes (12|34) or (12|34)(12|34) |
| 481 | $regex = preg_replace_callback('/(\([^\)]+\))\{(\d+),(\d+)\}/', function ($matches) { |
| 482 | return str_repeat($matches[1], Base::randomElement(range($matches[2], $matches[3]))); |
| 483 | }, $regex); |
| 484 | // A{1,2} becomes A or AA or \d{3} becomes \d\d\d |
| 485 | $regex = preg_replace_callback('/(\\\?.)\{(\d+),(\d+)\}/', function ($matches) { |
| 486 | return str_repeat($matches[1], Base::randomElement(range($matches[2], $matches[3]))); |
| 487 | }, $regex); |
| 488 | // (this|that) becomes 'this' or 'that' |
| 489 | $regex = preg_replace_callback('/\((.*?)\)/', function ($matches) { |
| 490 | return Base::randomElement(explode('|', str_replace(array('(', ')'), '', $matches[1]))); |
| 491 | }, $regex); |
| 492 | // All A-F inside of [] become ABCDEF |
| 493 | $regex = preg_replace_callback('/\[([^\]]+)\]/', function ($matches) { |
| 494 | return '[' . preg_replace_callback('/(\w|\d)\-(\w|\d)/', function ($range) { |
| 495 | return implode('', range($range[1], $range[2])); |
| 496 | }, $matches[1]) . ']'; |
| 497 | }, $regex); |
| 498 | // All [ABC] become B (or A or C) |
| 499 | $regex = preg_replace_callback('/\[([^\]]+)\]/', function ($matches) { |
| 500 | return Base::randomElement(str_split($matches[1])); |
| 501 | }, $regex); |
| 502 | // replace \d with number and \w with letter and . with ascii |
| 503 | $regex = preg_replace_callback('/\\\w/', 'static::randomLetter', $regex); |
| 504 | $regex = preg_replace_callback('/\\\d/', 'static::randomDigit', $regex); |
| 505 | $regex = preg_replace_callback('/(?<!\\\)\./', 'static::randomAscii', $regex); |
| 506 | // remove remaining backslashes |
| 507 | $regex = str_replace('\\', '', $regex); |
| 508 | // phew |
| 509 | return $regex; |
| 510 | } |
| 511 | |
| 512 | /** |
| 513 | * Converts string to lowercase. |
| 514 | * Uses mb_string extension if available. |
| 515 | * |
| 516 | * @param string $string String that should be converted to lowercase |
| 517 | * @return string |
| 518 | */ |
| 519 | public static function toLower($string = '') |
| 520 | { |
| 521 | return extension_loaded('mbstring') ? mb_strtolower($string, 'UTF-8') : strtolower($string); |
| 522 | } |
| 523 | |
| 524 | /** |
| 525 | * Converts string to uppercase. |
| 526 | * Uses mb_string extension if available. |
| 527 | * |
| 528 | * @param string $string String that should be converted to uppercase |
| 529 | * @return string |
| 530 | */ |
| 531 | public static function toUpper($string = '') |
| 532 | { |
| 533 | return extension_loaded('mbstring') ? mb_strtoupper($string, 'UTF-8') : strtoupper($string); |
| 534 | } |
| 535 | |
| 536 | /** |
| 537 | * Chainable method for making any formatter optional. |
| 538 | * |
| 539 | * @param float|integer $weight Set the probability of receiving a null value. |
| 540 | * "0" will always return null, "1" will always return the generator. |
| 541 | * If $weight is an integer value, then the same system works |
| 542 | * between 0 (always get false) and 100 (always get true). |
| 543 | * @return mixed|null |
| 544 | */ |
| 545 | public function optional($weight = 0.5, $default = null) |
| 546 | { |
| 547 | // old system based on 0.1 <= $weight <= 0.9 |
| 548 | // TODO: remove in v2 |
| 549 | if ($weight > 0 && $weight < 1 && mt_rand() / mt_getrandmax() <= $weight) { |
| 550 | return $this->generator; |
| 551 | } |
| 552 | |
| 553 | // new system with percentage |
| 554 | if (is_int($weight) && mt_rand(1, 100) <= $weight) { |
| 555 | return $this->generator; |
| 556 | } |
| 557 | |
| 558 | return new DefaultGenerator($default); |
| 559 | } |
| 560 | |
| 561 | /** |
| 562 | * Chainable method for making any formatter unique. |
| 563 | * |
| 564 | * <code> |
| 565 | * // will never return twice the same value |
| 566 | * $faker->unique()->randomElement(array(1, 2, 3)); |
| 567 | * </code> |
| 568 | * |
| 569 | * @param boolean $reset If set to true, resets the list of existing values |
| 570 | * @param integer $maxRetries Maximum number of retries to find a unique value, |
| 571 | * After which an OverflowException is thrown. |
| 572 | * @throws \OverflowException When no unique value can be found by iterating $maxRetries times |
| 573 | * |
| 574 | * @return UniqueGenerator A proxy class returning only non-existing values |
| 575 | */ |
| 576 | public function unique($reset = false, $maxRetries = 10000) |
| 577 | { |
| 578 | if ($reset || !$this->unique) { |
| 579 | $this->unique = new UniqueGenerator($this->generator, $maxRetries); |
| 580 | } |
| 581 | |
| 582 | return $this->unique; |
| 583 | } |
| 584 | |
| 585 | /** |
| 586 | * Chainable method for forcing any formatter to return only valid values. |
| 587 | * |
| 588 | * The value validity is determined by a function passed as first argument. |
| 589 | * |
| 590 | * <code> |
| 591 | * $values = array(); |
| 592 | * $evenValidator = function ($digit) { |
| 593 | * return $digit % 2 === 0; |
| 594 | * }; |
| 595 | * for ($i=0; $i < 10; $i++) { |
| 596 | * $values []= $faker->valid($evenValidator)->randomDigit; |
| 597 | * } |
| 598 | * print_r($values); // [0, 4, 8, 4, 2, 6, 0, 8, 8, 6] |
| 599 | * </code> |
| 600 | * |
| 601 | * @param Closure $validator A function returning true for valid values |
| 602 | * @param integer $maxRetries Maximum number of retries to find a unique value, |
| 603 | * After which an OverflowException is thrown. |
| 604 | * @throws \OverflowException When no valid value can be found by iterating $maxRetries times |
| 605 | * |
| 606 | * @return ValidGenerator A proxy class returning only valid values |
| 607 | */ |
| 608 | public function valid($validator = null, $maxRetries = 10000) |
| 609 | { |
| 610 | return new ValidGenerator($this->generator, $validator, $maxRetries); |
| 611 | } |
| 612 | } |
| 613 |