Merge branch '5.2RC'5.2

3 files changed, 396 insertions, 0 deletions

diff --git a/vendor/ramsey/uuid/src/Math/BrickMathCalculator.php b/vendor/ramsey/uuid/src/Math/BrickMathCalculator.php
new file mode 100644
index 000000000..f2d86788c
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Math/BrickMathCalculator.php
@@ -0,0 +1,144 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Math;
+
+use Brick\Math\BigDecimal;
+use Brick\Math\BigInteger;
+use Brick\Math\Exception\MathException;
+use Brick\Math\RoundingMode as BrickMathRounding;
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Type\Decimal;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+use Ramsey\Uuid\Type\NumberInterface;
+
+/**
+ * A calculator using the brick/math library for arbitrary-precision arithmetic
+ *
+ * @psalm-immutable
+ */
+final class BrickMathCalculator implements CalculatorInterface
+{
+    private const ROUNDING_MODE_MAP = [
+        RoundingMode::UNNECESSARY => BrickMathRounding::UNNECESSARY,
+        RoundingMode::UP => BrickMathRounding::UP,
+        RoundingMode::DOWN => BrickMathRounding::DOWN,
+        RoundingMode::CEILING => BrickMathRounding::CEILING,
+        RoundingMode::FLOOR => BrickMathRounding::FLOOR,
+        RoundingMode::HALF_UP => BrickMathRounding::HALF_UP,
+        RoundingMode::HALF_DOWN => BrickMathRounding::HALF_DOWN,
+        RoundingMode::HALF_CEILING => BrickMathRounding::HALF_CEILING,
+        RoundingMode::HALF_FLOOR => BrickMathRounding::HALF_FLOOR,
+        RoundingMode::HALF_EVEN => BrickMathRounding::HALF_EVEN,
+    ];
+
+    public function add(NumberInterface $augend, NumberInterface ...$addends): NumberInterface
+    {
+        $sum = BigInteger::of($augend->toString());
+
+        foreach ($addends as $addend) {
+            $sum = $sum->plus($addend->toString());
+        }
+
+        return new IntegerObject((string) $sum);
+    }
+
+    public function subtract(NumberInterface $minuend, NumberInterface ...$subtrahends): NumberInterface
+    {
+        $difference = BigInteger::of($minuend->toString());
+
+        foreach ($subtrahends as $subtrahend) {
+            $difference = $difference->minus($subtrahend->toString());
+        }
+
+        return new IntegerObject((string) $difference);
+    }
+
+    public function multiply(NumberInterface $multiplicand, NumberInterface ...$multipliers): NumberInterface
+    {
+        $product = BigInteger::of($multiplicand->toString());
+
+        foreach ($multipliers as $multiplier) {
+            $product = $product->multipliedBy($multiplier->toString());
+        }
+
+        return new IntegerObject((string) $product);
+    }
+
+    public function divide(
+        int $roundingMode,
+        int $scale,
+        NumberInterface $dividend,
+        NumberInterface ...$divisors
+    ): NumberInterface {
+        $brickRounding = $this->getBrickRoundingMode($roundingMode);
+
+        $quotient = BigDecimal::of($dividend->toString());
+
+        foreach ($divisors as $divisor) {
+            $quotient = $quotient->dividedBy($divisor->toString(), $scale, $brickRounding);
+        }
+
+        if ($scale === 0) {
+            return new IntegerObject((string) $quotient->toBigInteger());
+        }
+
+        return new Decimal((string) $quotient);
+    }
+
+    public function fromBase(string $value, int $base): IntegerObject
+    {
+        try {
+            return new IntegerObject((string) BigInteger::fromBase($value, $base));
+        } catch (MathException | \InvalidArgumentException $exception) {
+            throw new InvalidArgumentException(
+                $exception->getMessage(),
+                (int) $exception->getCode(),
+                $exception
+            );
+        }
+    }
+
+    public function toBase(IntegerObject $value, int $base): string
+    {
+        try {
+            return BigInteger::of($value->toString())->toBase($base);
+        } catch (MathException | \InvalidArgumentException $exception) {
+            throw new InvalidArgumentException(
+                $exception->getMessage(),
+                (int) $exception->getCode(),
+                $exception
+            );
+        }
+    }
+
+    public function toHexadecimal(IntegerObject $value): Hexadecimal
+    {
+        return new Hexadecimal($this->toBase($value, 16));
+    }
+
+    public function toInteger(Hexadecimal $value): IntegerObject
+    {
+        return $this->fromBase($value->toString(), 16);
+    }
+
+    /**
+     * Maps ramsey/uuid rounding modes to those used by brick/math
+     */
+    private function getBrickRoundingMode(int $roundingMode): int
+    {
+        return self::ROUNDING_MODE_MAP[$roundingMode] ?? 0;
+    }
+}
diff --git a/vendor/ramsey/uuid/src/Math/CalculatorInterface.php b/vendor/ramsey/uuid/src/Math/CalculatorInterface.php
new file mode 100644
index 000000000..f03645d0f
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Math/CalculatorInterface.php
@@ -0,0 +1,106 @@
+<?php
+
+/**
+ * This file is part of the ramsey/uuid library
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ *
+ * @copyright Copyright (c) Ben Ramsey <ben@benramsey.com>
+ * @license http://opensource.org/licenses/MIT MIT
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Math;
+
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+use Ramsey\Uuid\Type\NumberInterface;
+
+/**
+ * A calculator performs arithmetic operations on numbers
+ *
+ * @psalm-immutable
+ */
+interface CalculatorInterface
+{
+    /**
+     * Returns the sum of all the provided parameters
+     *
+     * @param NumberInterface $augend The first addend (the integer being added to)
+     * @param NumberInterface ...$addends The additional integers to a add to the augend
+     *
+     * @return NumberInterface The sum of all the parameters
+     */
+    public function add(NumberInterface $augend, NumberInterface ...$addends): NumberInterface;
+
+    /**
+     * Returns the difference of all the provided parameters
+     *
+     * @param NumberInterface $minuend The integer being subtracted from
+     * @param NumberInterface ...$subtrahends The integers to subtract from the minuend
+     *
+     * @return NumberInterface The difference after subtracting all parameters
+     */
+    public function subtract(NumberInterface $minuend, NumberInterface ...$subtrahends): NumberInterface;
+
+    /**
+     * Returns the product of all the provided parameters
+     *
+     * @param NumberInterface $multiplicand The integer to be multiplied
+     * @param NumberInterface ...$multipliers The factors by which to multiply the multiplicand
+     *
+     * @return NumberInterface The product of multiplying all the provided parameters
+     */
+    public function multiply(NumberInterface $multiplicand, NumberInterface ...$multipliers): NumberInterface;
+
+    /**
+     * Returns the quotient of the provided parameters divided left-to-right
+     *
+     * @param int $roundingMode The RoundingMode constant to use for this operation
+     * @param int $scale The scale to use for this operation
+     * @param NumberInterface $dividend The integer to be divided
+     * @param NumberInterface ...$divisors The integers to divide $dividend by, in
+     *     the order in which the division operations should take place
+     *     (left-to-right)
+     *
+     * @return NumberInterface The quotient of dividing the provided parameters left-to-right
+     */
+    public function divide(
+        int $roundingMode,
+        int $scale,
+        NumberInterface $dividend,
+        NumberInterface ...$divisors
+    ): NumberInterface;
+
+    /**
+     * Converts a value from an arbitrary base to a base-10 integer value
+     *
+     * @param string $value The value to convert
+     * @param int $base The base to convert from (i.e., 2, 16, 32, etc.)
+     *
+     * @return IntegerObject The base-10 integer value of the converted value
+     */
+    public function fromBase(string $value, int $base): IntegerObject;
+
+    /**
+     * Converts a base-10 integer value to an arbitrary base
+     *
+     * @param IntegerObject $value The integer value to convert
+     * @param int $base The base to convert to (i.e., 2, 16, 32, etc.)
+     *
+     * @return string The value represented in the specified base
+     */
+    public function toBase(IntegerObject $value, int $base): string;
+
+    /**
+     * Converts an Integer instance to a Hexadecimal instance
+     */
+    public function toHexadecimal(IntegerObject $value): Hexadecimal;
+
+    /**
+     * Converts a Hexadecimal instance to an Integer instance
+     */
+    public function toInteger(Hexadecimal $value): IntegerObject;
+}
diff --git a/vendor/ramsey/uuid/src/Math/RoundingMode.php b/vendor/ramsey/uuid/src/Math/RoundingMode.php
new file mode 100644
index 000000000..e710270d0
--- /dev/null
+++ b/vendor/ramsey/uuid/src/Math/RoundingMode.php
@@ -0,0 +1,146 @@
+<?php
+
+/**
+ * This file was originally part of brick/math
+ *
+ * Copyright (c) 2013-present Benjamin Morel
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ *
+ * @link https://github.com/brick/math brick/math at GitHub
+ */
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Math;
+
+/**
+ * Specifies a rounding behavior for numerical operations capable of discarding
+ * precision.
+ *
+ * Each rounding mode indicates how the least significant returned digit of a
+ * rounded result is to be calculated. If fewer digits are returned than the
+ * digits needed to represent the exact numerical result, the discarded digits
+ * will be referred to as the discarded fraction regardless the digits'
+ * contribution to the value of the number. In other words, considered as a
+ * numerical value, the discarded fraction could have an absolute value greater
+ * than one.
+ */
+final class RoundingMode
+{
+    /**
+     * Private constructor. This class is not instantiable.
+     *
+     * @codeCoverageIgnore
+     */
+    private function __construct()
+    {
+    }
+
+    /**
+     * Asserts that the requested operation has an exact result, hence no
+     * rounding is necessary.
+     */
+    public const UNNECESSARY = 0;
+
+    /**
+     * Rounds away from zero.
+     *
+     * Always increments the digit prior to a nonzero discarded fraction.
+     * Note that this rounding mode never decreases the magnitude of the
+     * calculated value.
+     */
+    public const UP = 1;
+
+    /**
+     * Rounds towards zero.
+     *
+     * Never increments the digit prior to a discarded fraction (i.e.,
+     * truncates). Note that this rounding mode never increases the magnitude of
+     * the calculated value.
+     */
+    public const DOWN = 2;
+
+    /**
+     * Rounds towards positive infinity.
+     *
+     * If the result is positive, behaves as for UP; if negative, behaves as for
+     * DOWN. Note that this rounding mode never decreases the calculated value.
+     */
+    public const CEILING = 3;
+
+    /**
+     * Rounds towards negative infinity.
+     *
+     * If the result is positive, behave as for DOWN; if negative, behave as for
+     * UP. Note that this rounding mode never increases the calculated value.
+     */
+    public const FLOOR = 4;
+
+    /**
+     * Rounds towards "nearest neighbor" unless both neighbors are equidistant,
+     * in which case round up.
+     *
+     * Behaves as for UP if the discarded fraction is >= 0.5; otherwise, behaves
+     * as for DOWN. Note that this is the rounding mode commonly taught at
+     * school.
+     */
+    public const HALF_UP = 5;
+
+    /**
+     * Rounds towards "nearest neighbor" unless both neighbors are equidistant,
+     * in which case round down.
+     *
+     * Behaves as for UP if the discarded fraction is > 0.5; otherwise, behaves
+     * as for DOWN.
+     */
+    public const HALF_DOWN = 6;
+
+    /**
+     * Rounds towards "nearest neighbor" unless both neighbors are equidistant,
+     * in which case round towards positive infinity.
+     *
+     * If the result is positive, behaves as for HALF_UP; if negative, behaves
+     * as for HALF_DOWN.
+     */
+    public const HALF_CEILING = 7;
+
+    /**
+     * Rounds towards "nearest neighbor" unless both neighbors are equidistant,
+     * in which case round towards negative infinity.
+     *
+     * If the result is positive, behaves as for HALF_DOWN; if negative, behaves
+     * as for HALF_UP.
+     */
+    public const HALF_FLOOR = 8;
+
+    /**
+     * Rounds towards the "nearest neighbor" unless both neighbors are
+     * equidistant, in which case rounds towards the even neighbor.
+     *
+     * Behaves as for HALF_UP if the digit to the left of the discarded fraction
+     * is odd; behaves as for HALF_DOWN if it's even.
+     *
+     * Note that this is the rounding mode that statistically minimizes
+     * cumulative error when applied repeatedly over a sequence of calculations.
+     * It is sometimes known as "Banker's rounding", and is chiefly used in the
+     * USA.
+     */
+    public const HALF_EVEN = 9;
+}