first commit

lib/tus/vendor/symfony/clock/CHANGELOG.md

@@ -0,0 +1,20 @@
+CHANGELOG
+=========
+
+6.4
+---
+
+ * Add `DatePoint`: an immutable DateTime implementation with stricter error handling and return types
+ * Throw `DateMalformedStringException`/`DateInvalidTimeZoneException` when appropriate
+ * Add `$modifier` argument to the `now()` helper
+
+6.3
+---
+
+ * Add `ClockAwareTrait` to help write time-sensitive classes
+ * Add `Clock` class and `now()` function
+
+6.2
+---
+
+ * Add the component

lib/tus/vendor/symfony/clock/Clock.php

@@ -0,0 +1,89 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock;
+
+use Psr\Clock\ClockInterface as PsrClockInterface;
+
+/**
+ * A global clock.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class Clock implements ClockInterface
+{
+    private static ClockInterface $globalClock;
+
+    public function __construct(
+        private readonly ?PsrClockInterface $clock = null,
+        private ?\DateTimeZone $timezone = null,
+    ) {
+    }
+
+    /**
+     * Returns the current global clock.
+     *
+     * Note that you should prefer injecting a ClockInterface or using
+     * ClockAwareTrait when possible instead of using this method.
+     */
+    public static function get(): ClockInterface
+    {
+        return self::$globalClock ??= new NativeClock();
+    }
+
+    public static function set(PsrClockInterface $clock): void
+    {
+        self::$globalClock = $clock instanceof ClockInterface ? $clock : new self($clock);
+    }
+
+    public function now(): DatePoint
+    {
+        $now = ($this->clock ?? self::get())->now();
+
+        if (!$now instanceof DatePoint) {
+            $now = DatePoint::createFromInterface($now);
+        }
+
+        return isset($this->timezone) ? $now->setTimezone($this->timezone) : $now;
+    }
+
+    public function sleep(float|int $seconds): void
+    {
+        $clock = $this->clock ?? self::get();
+
+        if ($clock instanceof ClockInterface) {
+            $clock->sleep($seconds);
+        } else {
+            (new NativeClock())->sleep($seconds);
+        }
+    }
+
+    /**
+     * @throws \DateInvalidTimeZoneException When $timezone is invalid
+     */
+    public function withTimeZone(\DateTimeZone|string $timezone): static
+    {
+        if (\PHP_VERSION_ID >= 80300 && \is_string($timezone)) {
+            $timezone = new \DateTimeZone($timezone);
+        } elseif (\is_string($timezone)) {
+            try {
+                $timezone = new \DateTimeZone($timezone);
+            } catch (\Exception $e) {
+                throw new \DateInvalidTimeZoneException($e->getMessage(), $e->getCode(), $e);
+            }
+        }
+
+        $clone = clone $this;
+        $clone->timezone = $timezone;
+
+        return $clone;
+    }
+}

lib/tus/vendor/symfony/clock/ClockAwareTrait.php

@@ -0,0 +1,41 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock;
+
+use Psr\Clock\ClockInterface;
+use Symfony\Contracts\Service\Attribute\Required;
+
+/**
+ * A trait to help write time-sensitive classes.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+trait ClockAwareTrait
+{
+    private readonly ClockInterface $clock;
+
+    #[Required]
+    public function setClock(ClockInterface $clock): void
+    {
+        $this->clock = $clock;
+    }
+
+    /**
+     * @return DatePoint
+     */
+    protected function now(): \DateTimeImmutable
+    {
+        $now = ($this->clock ??= new Clock())->now();
+
+        return $now instanceof DatePoint ? $now : DatePoint::createFromInterface($now);
+    }
+}

lib/tus/vendor/symfony/clock/ClockInterface.php

@@ -0,0 +1,24 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock;
+
+use Psr\Clock\ClockInterface as PsrClockInterface;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+interface ClockInterface extends PsrClockInterface
+{
+    public function sleep(float|int $seconds): void;
+
+    public function withTimeZone(\DateTimeZone|string $timezone): static;
+}

lib/tus/vendor/symfony/clock/DatePoint.php

@@ -0,0 +1,136 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock;
+
+/**
+ * An immmutable DateTime with stricter error handling and return types than the native one.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class DatePoint extends \DateTimeImmutable
+{
+    /**
+     * @throws \DateMalformedStringException When $datetime is invalid
+     */
+    public function __construct(string $datetime = 'now', ?\DateTimeZone $timezone = null, ?parent $reference = null)
+    {
+        $now = $reference ?? Clock::get()->now();
+
+        if ('now' !== $datetime) {
+            if (!$now instanceof static) {
+                $now = static::createFromInterface($now);
+            }
+
+            if (\PHP_VERSION_ID < 80300) {
+                try {
+                    $builtInDate = new parent($datetime, $timezone ?? $now->getTimezone());
+                    $timezone = $builtInDate->getTimezone();
+                } catch (\Exception $e) {
+                    throw new \DateMalformedStringException($e->getMessage(), $e->getCode(), $e);
+                }
+            } else {
+                $builtInDate = new parent($datetime, $timezone ?? $now->getTimezone());
+                $timezone = $builtInDate->getTimezone();
+            }
+
+            $now = $now->setTimezone($timezone)->modify($datetime);
+
+            if ('00:00:00.000000' === $builtInDate->format('H:i:s.u')) {
+                $now = $now->setTime(0, 0);
+            }
+        } elseif (null !== $timezone) {
+            $now = $now->setTimezone($timezone);
+        }
+
+        if (\PHP_VERSION_ID < 80200) {
+            $now = (array) $now;
+            $this->date = $now['date'];
+            $this->timezone_type = $now['timezone_type'];
+            $this->timezone = $now['timezone'];
+            $this->__wakeup();
+
+            return;
+        }
+
+        $this->__unserialize((array) $now);
+    }
+
+    /**
+     * @throws \DateMalformedStringException When $format or $datetime are invalid
+     */
+    public static function createFromFormat(string $format, string $datetime, ?\DateTimeZone $timezone = null): static
+    {
+        return parent::createFromFormat($format, $datetime, $timezone) ?: throw new \DateMalformedStringException(static::getLastErrors()['errors'][0] ?? 'Invalid date string or format.');
+    }
+
+    public static function createFromInterface(\DateTimeInterface $object): static
+    {
+        return parent::createFromInterface($object);
+    }
+
+    public static function createFromMutable(\DateTime $object): static
+    {
+        return parent::createFromMutable($object);
+    }
+
+    public function add(\DateInterval $interval): static
+    {
+        return parent::add($interval);
+    }
+
+    public function sub(\DateInterval $interval): static
+    {
+        return parent::sub($interval);
+    }
+
+    /**
+     * @throws \DateMalformedStringException When $modifier is invalid
+     */
+    public function modify(string $modifier): static
+    {
+        if (\PHP_VERSION_ID < 80300) {
+            return @parent::modify($modifier) ?: throw new \DateMalformedStringException(error_get_last()['message'] ?? sprintf('Invalid modifier: "%s".', $modifier));
+        }
+
+        return parent::modify($modifier);
+    }
+
+    public function setTimestamp(int $value): static
+    {
+        return parent::setTimestamp($value);
+    }
+
+    public function setDate(int $year, int $month, int $day): static
+    {
+        return parent::setDate($year, $month, $day);
+    }
+
+    public function setISODate(int $year, int $week, int $day = 1): static
+    {
+        return parent::setISODate($year, $week, $day);
+    }
+
+    public function setTime(int $hour, int $minute, int $second = 0, int $microsecond = 0): static
+    {
+        return parent::setTime($hour, $minute, $second, $microsecond);
+    }
+
+    public function setTimezone(\DateTimeZone $timezone): static
+    {
+        return parent::setTimezone($timezone);
+    }
+
+    public function getTimezone(): \DateTimeZone
+    {
+        return parent::getTimezone() ?: throw new \DateInvalidTimeZoneException('The DatePoint object has no timezone.');
+    }
+}

lib/tus/vendor/symfony/clock/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2022-present Fabien Potencier
+
+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.

lib/tus/vendor/symfony/clock/MockClock.php

@@ -0,0 +1,98 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock;
+
+/**
+ * A clock that always returns the same date, suitable for testing time-sensitive logic.
+ *
+ * Consider using ClockSensitiveTrait in your test cases instead of using this class directly.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class MockClock implements ClockInterface
+{
+    private DatePoint $now;
+
+    /**
+     * @throws \DateMalformedStringException When $now is invalid
+     * @throws \DateInvalidTimeZoneException When $timezone is invalid
+     */
+    public function __construct(\DateTimeImmutable|string $now = 'now', \DateTimeZone|string|null $timezone = null)
+    {
+        if (\PHP_VERSION_ID >= 80300 && \is_string($timezone)) {
+            $timezone = new \DateTimeZone($timezone);
+        } elseif (\is_string($timezone)) {
+            try {
+                $timezone = new \DateTimeZone($timezone);
+            } catch (\Exception $e) {
+                throw new \DateInvalidTimeZoneException($e->getMessage(), $e->getCode(), $e);
+            }
+        }
+
+        if (\is_string($now)) {
+            $now = new DatePoint($now, $timezone ?? new \DateTimeZone('UTC'));
+        } elseif (!$now instanceof DatePoint) {
+            $now = DatePoint::createFromInterface($now);
+        }
+
+        $this->now = null !== $timezone ? $now->setTimezone($timezone) : $now;
+    }
+
+    public function now(): DatePoint
+    {
+        return clone $this->now;
+    }
+
+    public function sleep(float|int $seconds): void
+    {
+        $now = (float) $this->now->format('Uu') + $seconds * 1e6;
+        $now = substr_replace(sprintf('@%07.0F', $now), '.', -6, 0);
+        $timezone = $this->now->getTimezone();
+
+        $this->now = DatePoint::createFromInterface(new \DateTimeImmutable($now, $timezone))->setTimezone($timezone);
+    }
+
+    /**
+     * @throws \DateMalformedStringException When $modifier is invalid
+     */
+    public function modify(string $modifier): void
+    {
+        if (\PHP_VERSION_ID < 80300) {
+            $this->now = @$this->now->modify($modifier) ?: throw new \DateMalformedStringException(error_get_last()['message'] ?? sprintf('Invalid modifier: "%s". Could not modify MockClock.', $modifier));
+
+            return;
+        }
+
+        $this->now = $this->now->modify($modifier);
+    }
+
+    /**
+     * @throws \DateInvalidTimeZoneException When the timezone name is invalid
+     */
+    public function withTimeZone(\DateTimeZone|string $timezone): static
+    {
+        if (\PHP_VERSION_ID >= 80300 && \is_string($timezone)) {
+            $timezone = new \DateTimeZone($timezone);
+        } elseif (\is_string($timezone)) {
+            try {
+                $timezone = new \DateTimeZone($timezone);
+            } catch (\Exception $e) {
+                throw new \DateInvalidTimeZoneException($e->getMessage(), $e->getCode(), $e);
+            }
+        }
+
+        $clone = clone $this;
+        $clone->now = $clone->now->setTimezone($timezone);
+
+        return $clone;
+    }
+}

lib/tus/vendor/symfony/clock/MonotonicClock.php

@@ -0,0 +1,93 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock;
+
+/**
+ * A monotonic clock suitable for performance profiling.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class MonotonicClock implements ClockInterface
+{
+    private int $sOffset;
+    private int $usOffset;
+    private \DateTimeZone $timezone;
+
+    /**
+     * @throws \DateInvalidTimeZoneException When $timezone is invalid
+     */
+    public function __construct(\DateTimeZone|string|null $timezone = null)
+    {
+        if (false === $offset = hrtime()) {
+            throw new \RuntimeException('hrtime() returned false: the runtime environment does not provide access to a monotonic timer.');
+        }
+
+        $time = explode(' ', microtime(), 2);
+        $this->sOffset = $time[1] - $offset[0];
+        $this->usOffset = (int) ($time[0] * 1000000) - (int) ($offset[1] / 1000);
+
+        $this->timezone = \is_string($timezone ??= date_default_timezone_get()) ? $this->withTimeZone($timezone)->timezone : $timezone;
+    }
+
+    public function now(): DatePoint
+    {
+        [$s, $us] = hrtime();
+
+        if (1000000 <= $us = (int) ($us / 1000) + $this->usOffset) {
+            ++$s;
+            $us -= 1000000;
+        } elseif (0 > $us) {
+            --$s;
+            $us += 1000000;
+        }
+
+        if (6 !== \strlen($now = (string) $us)) {
+            $now = str_pad($now, 6, '0', \STR_PAD_LEFT);
+        }
+
+        $now = '@'.($s + $this->sOffset).'.'.$now;
+
+        return DatePoint::createFromInterface(new \DateTimeImmutable($now, $this->timezone))->setTimezone($this->timezone);
+    }
+
+    public function sleep(float|int $seconds): void
+    {
+        if (0 < $s = (int) $seconds) {
+            sleep($s);
+        }
+
+        if (0 < $us = $seconds - $s) {
+            usleep((int) ($us * 1E6));
+        }
+    }
+
+    /**
+     * @throws \DateInvalidTimeZoneException When $timezone is invalid
+     */
+    public function withTimeZone(\DateTimeZone|string $timezone): static
+    {
+        if (\PHP_VERSION_ID >= 80300 && \is_string($timezone)) {
+            $timezone = new \DateTimeZone($timezone);
+        } elseif (\is_string($timezone)) {
+            try {
+                $timezone = new \DateTimeZone($timezone);
+            } catch (\Exception $e) {
+                throw new \DateInvalidTimeZoneException($e->getMessage(), $e->getCode(), $e);
+            }
+        }
+
+        $clone = clone $this;
+        $clone->timezone = $timezone;
+
+        return $clone;
+    }
+}

lib/tus/vendor/symfony/clock/NativeClock.php

@@ -0,0 +1,67 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock;
+
+/**
+ * A clock that relies the system time.
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+final class NativeClock implements ClockInterface
+{
+    private \DateTimeZone $timezone;
+
+    /**
+     * @throws \DateInvalidTimeZoneException When $timezone is invalid
+     */
+    public function __construct(\DateTimeZone|string|null $timezone = null)
+    {
+        $this->timezone = \is_string($timezone ??= date_default_timezone_get()) ? $this->withTimeZone($timezone)->timezone : $timezone;
+    }
+
+    public function now(): DatePoint
+    {
+        return DatePoint::createFromInterface(new \DateTimeImmutable('now', $this->timezone));
+    }
+
+    public function sleep(float|int $seconds): void
+    {
+        if (0 < $s = (int) $seconds) {
+            sleep($s);
+        }
+
+        if (0 < $us = $seconds - $s) {
+            usleep((int) ($us * 1E6));
+        }
+    }
+
+    /**
+     * @throws \DateInvalidTimeZoneException When $timezone is invalid
+     */
+    public function withTimeZone(\DateTimeZone|string $timezone): static
+    {
+        if (\PHP_VERSION_ID >= 80300 && \is_string($timezone)) {
+            $timezone = new \DateTimeZone($timezone);
+        } elseif (\is_string($timezone)) {
+            try {
+                $timezone = new \DateTimeZone($timezone);
+            } catch (\Exception $e) {
+                throw new \DateInvalidTimeZoneException($e->getMessage(), $e->getCode(), $e);
+            }
+        }
+
+        $clone = clone $this;
+        $clone->timezone = $timezone;
+
+        return $clone;
+    }
+}

lib/tus/vendor/symfony/clock/README.md

@@ -0,0 +1,47 @@
+Clock Component
+===============
+
+Symfony Clock decouples applications from the system clock.
+
+Getting Started
+---------------
+
+```
+$ composer require symfony/clock
+```
+
+```php
+use Symfony\Component\Clock\NativeClock;
+use Symfony\Component\Clock\ClockInterface;
+
+class MyClockSensitiveClass
+{
+    public function __construct(
+        private ClockInterface $clock,
+    ) {
+        // Only if you need to force a timezone:
+        //$this->clock = $clock->withTimeZone('UTC');
+    }
+
+    public function doSomething()
+    {
+        $now = $this->clock->now();
+        // [...] do something with $now, which is a \DateTimeImmutable object
+
+        $this->clock->sleep(2.5); // Pause execution for 2.5 seconds
+    }
+}
+
+$clock = new NativeClock();
+$service = new MyClockSensitiveClass($clock);
+$service->doSomething();
+```
+
+Resources
+---------
+
+ * [Documentation](https://symfony.com/doc/current/components/clock.html)
+ * [Contributing](https://symfony.com/doc/current/contributing/index.html)
+ * [Report issues](https://github.com/symfony/symfony/issues) and
+   [send Pull Requests](https://github.com/symfony/symfony/pulls)
+   in the [main Symfony repository](https://github.com/symfony/symfony)

lib/tus/vendor/symfony/clock/Resources/now.php

@@ -0,0 +1,28 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock;
+
+if (!\function_exists(now::class)) {
+    /**
+     * @throws \DateMalformedStringException When the modifier is invalid
+     */
+    function now(string $modifier = 'now'): DatePoint
+    {
+        if ('now' !== $modifier) {
+            return new DatePoint($modifier);
+        }
+
+        $now = Clock::get()->now();
+
+        return $now instanceof DatePoint ? $now : DatePoint::createFromInterface($now);
+    }
+}

lib/tus/vendor/symfony/clock/Test/ClockSensitiveTrait.php

@@ -0,0 +1,77 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Clock\Test;
+
+use PHPUnit\Framework\Attributes\After;
+use PHPUnit\Framework\Attributes\Before;
+use PHPUnit\Framework\Attributes\BeforeClass;
+use Psr\Clock\ClockInterface;
+use Symfony\Component\Clock\Clock;
+use Symfony\Component\Clock\MockClock;
+
+use function Symfony\Component\Clock\now;
+
+/**
+ * Helps with mocking the time in your test cases.
+ *
+ * This trait provides one self::mockTime() method that freezes the time.
+ * It restores the global clock after each test case.
+ * self::mockTime() accepts either a string (eg '+1 days' or '2022-12-22'),
+ * a DateTimeImmutable, or a boolean (to freeze/restore the global clock).
+ *
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+trait ClockSensitiveTrait
+{
+    public static function mockTime(string|\DateTimeImmutable|bool $when = true): ClockInterface
+    {
+        Clock::set(match (true) {
+            false === $when => self::saveClockBeforeTest(false),
+            true === $when => new MockClock(),
+            $when instanceof \DateTimeImmutable => new MockClock($when),
+            default => new MockClock(now($when)),
+        });
+
+        return Clock::get();
+    }
+
+    /**
+     * @beforeClass
+     *
+     * @before
+     *
+     * @internal
+     */
+    #[Before]
+    #[BeforeClass]
+    public static function saveClockBeforeTest(bool $save = true): ClockInterface
+    {
+        static $originalClock;
+
+        if ($save && $originalClock) {
+            self::restoreClockAfterTest();
+        }
+
+        return $save ? $originalClock = Clock::get() : $originalClock;
+    }
+
+    /**
+     * @after
+     *
+     * @internal
+     */
+    #[After]
+    protected static function restoreClockAfterTest(): void
+    {
+        Clock::set(self::saveClockBeforeTest(false));
+    }
+}

lib/tus/vendor/symfony/clock/composer.json

@@ -0,0 +1,34 @@
+{
+    "name": "symfony/clock",
+    "type": "library",
+    "description": "Decouples applications from the system clock",
+    "keywords": ["clock", "time", "psr20"],
+    "homepage": "https://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Nicolas Grekas",
+            "email": "p@tchwork.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "https://symfony.com/contributors"
+        }
+    ],
+    "provide": {
+        "psr/clock-implementation": "1.0"
+    },
+    "require": {
+        "php": ">=8.1",
+        "psr/clock": "^1.0",
+        "symfony/polyfill-php83": "^1.28"
+    },
+    "autoload": {
+        "files": [ "Resources/now.php" ],
+        "psr-4": { "Symfony\\Component\\Clock\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "minimum-stability": "dev"
+}