JordanRL /
Fermat
| Total Complexity | 40 |
| Total Lines | 398 |
| Duplicated Lines | 0 % |
| Coverage | 73.32% |
| Changes | 1 | ||
| Bugs | 0 | Features | 0 |
Complex classes like RandomProvider often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use RandomProvider, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 19 | class RandomProvider |
||
| 20 | { |
||
| 21 | |||
| 22 | /** @noinspection PhpDocMissingThrowsInspection */ |
||
| 23 | /** |
||
| 24 | * @param int|string|DecimalInterface $min |
||
| 25 | * @param int|string|DecimalInterface $max |
||
| 26 | * @param RandomMode $mode |
||
| 27 | * @return ImmutableDecimal |
||
| 28 | * @throws IntegrityConstraint |
||
| 29 | * @throws OptionalExit |
||
| 30 | * @throws IncompatibleObjectState |
||
| 31 | */ |
||
| 32 | 12 | public static function randomInt( |
|
| 33 | int|string|DecimalInterface $min, |
||
| 34 | int|string|DecimalInterface $max, |
||
| 35 | RandomMode $mode = RandomMode::Entropy |
||
| 36 | ): ImmutableDecimal |
||
| 37 | { |
||
| 38 | 12 | $minDecimal = Numbers::makeOrDont(Numbers::IMMUTABLE, $min); |
|
| 39 | 12 | $maxDecimal = Numbers::makeOrDont(Numbers::IMMUTABLE, $max); |
|
| 40 | |||
| 41 | /** |
||
| 42 | * We want to prevent providing non-integer values for min and max, even in cases where |
||
| 43 | * the supplied value is a string or a DecimalInterface. |
||
| 44 | */ |
||
| 45 | 12 | if ($minDecimal->isFloat() || $maxDecimal->isFloat()) { |
|
|
Bug
introduced
by
|
|||
| 46 | throw new IntegrityConstraint( |
||
| 47 | 'Random integers cannot be generated with boundaries which are floats', |
||
| 48 | 'Provide only whole number, integer values for min and max.', |
||
| 49 | 'An attempt was made to generate a random integer with boundaries which are non-integers. Min Provided: '.$min->getValue(NumberBase::Ten).' -- Max Provided: '.$max->getValue(NumberBase::Ten) |
||
| 50 | ); |
||
| 51 | } |
||
| 52 | |||
| 53 | /** |
||
| 54 | * Because of optimistic optimizing with the rand() and random_int() functions, we do |
||
| 55 | * need the arguments to be provided in the correct order. |
||
| 56 | */ |
||
| 57 | 12 | if ($minDecimal->isGreaterThan($maxDecimal)) { |
|
| 58 | throw new IntegrityConstraint( |
||
| 59 | 'Minimum is larger than maximum.', |
||
| 60 | 'Please provide your arguments in the correct order.', |
||
| 61 | 'The supplied minimum value for randomInt() was greater than the supplied maximum value.' |
||
| 62 | ); |
||
| 63 | } |
||
| 64 | |||
| 65 | /** |
||
| 66 | * For some applications it might be better to throw an exception here, however it |
||
| 67 | * would probably be hard to recover in most applications from a situation which |
||
| 68 | * resulted in this situation. |
||
| 69 | * |
||
| 70 | * So instead we will trigger a language level warning and return the only valid |
||
| 71 | * value for the parameters given. |
||
| 72 | */ |
||
| 73 | 12 | if ($minDecimal->isEqual($maxDecimal)) { |
|
| 74 | 1 | trigger_error( |
|
| 75 | 1 | 'Attempted to get a random value for a range of no size, with minimum of '.$minDecimal->getValue(NumberBase::Ten).' and maximum of '.$maxDecimal->getValue(NumberBase::Ten), |
|
| 76 | E_USER_WARNING |
||
| 77 | ); |
||
| 78 | |||
| 79 | return $minDecimal; |
||
| 80 | } |
||
| 81 | |||
| 82 | 11 | if ($minDecimal->isLessThanOrEqualTo(PHP_INT_MAX) && $minDecimal->isGreaterThanOrEqualTo(PHP_INT_MIN)) { |
|
| 83 | /** @noinspection PhpUnhandledExceptionInspection */ |
||
| 84 | 11 | $min = $minDecimal->asInt(); |
|
| 85 | } |
||
| 86 | |||
| 87 | 11 | if ($maxDecimal->isLessThanOrEqualTo(PHP_INT_MAX) && $maxDecimal->isGreaterThanOrEqualTo(PHP_INT_MIN)) { |
|
| 88 | /** @noinspection PhpUnhandledExceptionInspection */ |
||
| 89 | 10 | $max = $maxDecimal->asInt(); |
|
| 90 | } |
||
| 91 | |||
| 92 | 11 | if (is_int($min) && is_int($max)) { |
|
| 93 | 10 | if ($mode == RandomMode::Entropy || $max > getrandmax() || $max < 0 || $min < 0) { |
|
| 94 | /** |
||
| 95 | * The random_int() function is cryptographically secure, and takes somewhere on the order |
||
| 96 | * of 15 times as long to execute as rand(). However, rand() also has a smaller range than |
||
| 97 | * the entire PHP integer size, so there are some situations where we need to use this |
||
| 98 | * function even if MODE_SPEED is selected. |
||
| 99 | * |
||
| 100 | * In those cases, random_int() is still faster than calls to random_bytes() and manual |
||
| 101 | * masking. |
||
| 102 | */ |
||
| 103 | try { |
||
| 104 | 8 | $num = random_int($min, $max); |
|
| 105 | 8 | return new ImmutableDecimal($num); |
|
| 106 | } catch (Exception $e) { |
||
| 107 | throw new OptionalExit( |
||
| 108 | 'System error from random_bytes().', |
||
| 109 | 'Ensure your system is configured correctly.', |
||
| 110 | 'A call to random_bytes() threw a system level exception. Most often this is due to a problem with entropy sources in your configuration. Original exception message: ' . $e->getMessage() |
||
| 111 | ); |
||
| 112 | } |
||
| 113 | 4 | } elseif ($mode == RandomMode::Speed) { |
|
| 114 | /** |
||
| 115 | * If it is possible to do so with the range given and the program has indicated that it |
||
| 116 | * would prefer speed to true randomness in the result, then we will use the deterministic |
||
| 117 | * pseudo-random function rand() as it is faster to reach completion. |
||
| 118 | */ |
||
| 119 | 4 | $num = rand($min, $max); |
|
| 120 | 4 | return new ImmutableDecimal($num); |
|
| 121 | } else { |
||
| 122 | throw new IntegrityConstraint( |
||
| 123 | 'Mode on random functions must be an implemented mode.', |
||
| 124 | 'Choose modes using the class constants.', |
||
| 125 | 'A mode was provided to randomInt() that does not correspond to any implementation. Please only use the class constants for selecting the mode.' |
||
| 126 | ); |
||
| 127 | } |
||
| 128 | } else { |
||
| 129 | /** |
||
| 130 | * We only need to request enough bytes to find a number within the range, since we |
||
| 131 | * will be adding the minimum value to it at the end. |
||
| 132 | */ |
||
| 133 | /** @noinspection PhpUnhandledExceptionInspection */ |
||
| 134 | 1 | $range = $maxDecimal->subtract($minDecimal); |
|
| 135 | /** @noinspection PhpUnhandledExceptionInspection */ |
||
| 136 | 1 | $bitsNeeded = $range->ln(2)->divide(Numbers::makeNaturalLog2(2), 2)->floor()->add(1); |
|
| 137 | 1 | $bytesNeeded = $bitsNeeded->divide(8, 2)->ceil(); |
|
| 138 | |||
| 139 | do { |
||
| 140 | try { |
||
| 141 | /** |
||
| 142 | * Returns random bytes based on sources of entropy within the system. |
||
| 143 | * |
||
| 144 | * For documentation on these sources please see: |
||
| 145 | * |
||
| 146 | * https://www.php.net/manual/en/function.random-bytes.php |
||
| 147 | */ |
||
| 148 | 1 | $entropyBytes = random_bytes($bytesNeeded->asInt()); |
|
| 149 | 1 | $baseTwoBytes = ''; |
|
| 150 | 1 | for($i = 0; $i < strlen($entropyBytes); $i++){ |
|
| 151 | 1 | $baseTwoBytes .= decbin( ord( $entropyBytes[$i] ) ); |
|
| 152 | } |
||
| 153 | } catch (Exception $e) { |
||
| 154 | throw new OptionalExit( |
||
| 155 | 'System error from random_bytes().', |
||
| 156 | 'Ensure your system is configured correctly.', |
||
| 157 | 'A call to random_bytes() threw a system level exception. Most often this is due to a problem with entropy sources in your configuration. Original exception message: ' . $e->getMessage() |
||
| 158 | ); |
||
| 159 | } |
||
| 160 | |||
| 161 | 1 | $randomValue = BaseConversionProvider::convertStringToBaseTen($baseTwoBytes, NumberBase::Two); |
|
| 162 | |||
| 163 | /** |
||
| 164 | * @var ImmutableDecimal $num |
||
| 165 | * |
||
| 166 | * Since the number of digits is equal to the bits needed, but random_bytes() only |
||
| 167 | * returns in chunks of 8 bits (duh, bytes), we can substr() from the right to |
||
| 168 | * select only the correct number of digits by multiplying the number of bits |
||
| 169 | * needed by -1 and using that as the starting point. |
||
| 170 | */ |
||
| 171 | 1 | $num = Numbers::make( |
|
| 172 | type: Numbers::IMMUTABLE, |
||
| 173 | 1 | value: substr($randomValue, $bitsNeeded->multiply(-1)->asInt()) |
|
| 174 | ); |
||
| 175 | 1 | } while ($num->isGreaterThan($range)); |
|
| 176 | /** |
||
| 177 | * It is strictly speaking possible for this to loop infinitely. In the worst case |
||
| 178 | * scenario where 50% of possible values are invalid, it takes 7 loops for there to |
||
| 179 | * be a less than a 1% chance of still not having an answer. |
||
| 180 | * |
||
| 181 | * After only 10 loops the chance is less than 1/1000. |
||
| 182 | */ |
||
| 183 | |||
| 184 | /** |
||
| 185 | * Add the minimum since we effectively subtracted it by finding a random number |
||
| 186 | * bounded between 0 and range. If our requested range included negative numbers, |
||
| 187 | * this operation will also return those values into our data by effectively |
||
| 188 | * shifting the result window. |
||
| 189 | */ |
||
| 190 | /** @noinspection PhpUnhandledExceptionInspection */ |
||
| 191 | 1 | return $num->add($minDecimal); |
|
| 192 | } |
||
| 193 | } |
||
| 194 | |||
| 195 | /** |
||
| 196 | * @param int $scale |
||
| 197 | * @param RandomMode $mode |
||
| 198 | * @return ImmutableDecimal |
||
| 199 | * @throws IntegrityConstraint |
||
| 200 | * @throws OptionalExit |
||
| 201 | * @throws IncompatibleObjectState |
||
| 202 | */ |
||
| 203 | 2 | public static function randomDecimal( |
|
| 204 | int $scale = 10, |
||
| 205 | RandomMode $mode = RandomMode::Entropy |
||
| 206 | ): ImmutableDecimal |
||
| 207 | { |
||
| 208 | /** |
||
| 209 | * Select the min and max as if we were looking for the decimal part as an integer. |
||
| 210 | */ |
||
| 211 | 2 | $min = new ImmutableDecimal(0); |
|
| 212 | 2 | $max = new ImmutableDecimal(str_pad('1', $scale+1, '0')); |
|
| 213 | |||
| 214 | /** |
||
| 215 | * This allows us to utilize the same randomInt() function. |
||
| 216 | */ |
||
| 217 | 2 | $randomValue = self::randomInt($min, $max, $mode); |
|
| 218 | |||
| 219 | /** |
||
| 220 | * If the random value exactly equals our min or max, that means we need to return |
||
| 221 | * either 1 or 0. |
||
| 222 | */ |
||
| 223 | 2 | if ($randomValue->isEqual($min) || $randomValue->isEqual($max)) { |
|
| 224 | return $randomValue->isPositive() ? new ImmutableDecimal(1) : $min; |
||
| 225 | } |
||
| 226 | |||
| 227 | /** |
||
| 228 | * In all other cases we need to reformat our integer as being the decimal portion |
||
| 229 | * of our number at the given scale. |
||
| 230 | */ |
||
| 231 | 2 | return new ImmutableDecimal('0.'.str_pad($randomValue->getValue(NumberBase::Ten), $scale, '0', STR_PAD_LEFT)); |
|
| 232 | } |
||
| 233 | |||
| 234 | /** @noinspection PhpDocMissingThrowsInspection */ |
||
| 235 | /** |
||
| 236 | * @param int|string|DecimalInterface $min |
||
| 237 | * @param int|string|DecimalInterface $max |
||
| 238 | * @param int $scale |
||
| 239 | * @param RandomMode $mode |
||
| 240 | * @return ImmutableDecimal |
||
| 241 | * @throws IntegrityConstraint |
||
| 242 | * @throws OptionalExit |
||
| 243 | * @throws IncompatibleObjectState |
||
| 244 | */ |
||
| 245 | 3 | public static function randomReal( |
|
| 417 | } |
||
| 418 | |||
| 419 | } |
Loading history...