updated-packages

vendor/doctrine/cache/lib/Doctrine/Common/Cache/Psr6/CacheAdapter.php

@@ -0,0 +1,340 @@
+<?php
+
+namespace Doctrine\Common\Cache\Psr6;
+
+use Doctrine\Common\Cache\Cache;
+use Doctrine\Common\Cache\ClearableCache;
+use Doctrine\Common\Cache\MultiDeleteCache;
+use Doctrine\Common\Cache\MultiGetCache;
+use Doctrine\Common\Cache\MultiPutCache;
+use Psr\Cache\CacheItemInterface;
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\Cache\DoctrineProvider as SymfonyDoctrineProvider;
+
+use function array_key_exists;
+use function assert;
+use function count;
+use function current;
+use function get_class;
+use function gettype;
+use function is_object;
+use function is_string;
+use function microtime;
+use function sprintf;
+use function strpbrk;
+
+use const PHP_VERSION_ID;
+
+final class CacheAdapter implements CacheItemPoolInterface
+{
+    private const RESERVED_CHARACTERS = '{}()/\@:';
+
+    /** @var Cache */
+    private $cache;
+
+    /** @var array<CacheItem|TypedCacheItem> */
+    private $deferredItems = [];
+
+    public static function wrap(Cache $cache): CacheItemPoolInterface
+    {
+        if ($cache instanceof DoctrineProvider && ! $cache->getNamespace()) {
+            return $cache->getPool();
+        }
+
+        if ($cache instanceof SymfonyDoctrineProvider && ! $cache->getNamespace()) {
+            $getPool = function () {
+                // phpcs:ignore Squiz.Scope.StaticThisUsage.Found
+                return $this->pool;
+            };
+
+            return $getPool->bindTo($cache, SymfonyDoctrineProvider::class)();
+        }
+
+        return new self($cache);
+    }
+
+    private function __construct(Cache $cache)
+    {
+        $this->cache = $cache;
+    }
+
+    /** @internal */
+    public function getCache(): Cache
+    {
+        return $this->cache;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getItem($key): CacheItemInterface
+    {
+        assert(self::validKey($key));
+
+        if (isset($this->deferredItems[$key])) {
+            $this->commit();
+        }
+
+        $value = $this->cache->fetch($key);
+
+        if (PHP_VERSION_ID >= 80000) {
+            if ($value !== false) {
+                return new TypedCacheItem($key, $value, true);
+            }
+
+            return new TypedCacheItem($key, null, false);
+        }
+
+        if ($value !== false) {
+            return new CacheItem($key, $value, true);
+        }
+
+        return new CacheItem($key, null, false);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function getItems(array $keys = []): array
+    {
+        if ($this->deferredItems) {
+            $this->commit();
+        }
+
+        assert(self::validKeys($keys));
+
+        $values = $this->doFetchMultiple($keys);
+        $items  = [];
+
+        if (PHP_VERSION_ID >= 80000) {
+            foreach ($keys as $key) {
+                if (array_key_exists($key, $values)) {
+                    $items[$key] = new TypedCacheItem($key, $values[$key], true);
+                } else {
+                    $items[$key] = new TypedCacheItem($key, null, false);
+                }
+            }
+
+            return $items;
+        }
+
+        foreach ($keys as $key) {
+            if (array_key_exists($key, $values)) {
+                $items[$key] = new CacheItem($key, $values[$key], true);
+            } else {
+                $items[$key] = new CacheItem($key, null, false);
+            }
+        }
+
+        return $items;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function hasItem($key): bool
+    {
+        assert(self::validKey($key));
+
+        if (isset($this->deferredItems[$key])) {
+            $this->commit();
+        }
+
+        return $this->cache->contains($key);
+    }
+
+    public function clear(): bool
+    {
+        $this->deferredItems = [];
+
+        if (! $this->cache instanceof ClearableCache) {
+            return false;
+        }
+
+        return $this->cache->deleteAll();
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function deleteItem($key): bool
+    {
+        assert(self::validKey($key));
+        unset($this->deferredItems[$key]);
+
+        return $this->cache->delete($key);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function deleteItems(array $keys): bool
+    {
+        foreach ($keys as $key) {
+            assert(self::validKey($key));
+            unset($this->deferredItems[$key]);
+        }
+
+        return $this->doDeleteMultiple($keys);
+    }
+
+    public function save(CacheItemInterface $item): bool
+    {
+        return $this->saveDeferred($item) && $this->commit();
+    }
+
+    public function saveDeferred(CacheItemInterface $item): bool
+    {
+        if (! $item instanceof CacheItem && ! $item instanceof TypedCacheItem) {
+            return false;
+        }
+
+        $this->deferredItems[$item->getKey()] = $item;
+
+        return true;
+    }
+
+    public function commit(): bool
+    {
+        if (! $this->deferredItems) {
+            return true;
+        }
+
+        $now         = microtime(true);
+        $itemsCount  = 0;
+        $byLifetime  = [];
+        $expiredKeys = [];
+
+        foreach ($this->deferredItems as $key => $item) {
+            $lifetime = ($item->getExpiry() ?? $now) - $now;
+
+            if ($lifetime < 0) {
+                $expiredKeys[] = $key;
+
+                continue;
+            }
+
+            ++$itemsCount;
+            $byLifetime[(int) $lifetime][$key] = $item->get();
+        }
+
+        $this->deferredItems = [];
+
+        switch (count($expiredKeys)) {
+            case 0:
+                break;
+            case 1:
+                $this->cache->delete(current($expiredKeys));
+                break;
+            default:
+                $this->doDeleteMultiple($expiredKeys);
+                break;
+        }
+
+        if ($itemsCount === 1) {
+            return $this->cache->save($key, $item->get(), (int) $lifetime);
+        }
+
+        $success = true;
+        foreach ($byLifetime as $lifetime => $values) {
+            $success = $this->doSaveMultiple($values, $lifetime) && $success;
+        }
+
+        return $success;
+    }
+
+    public function __destruct()
+    {
+        $this->commit();
+    }
+
+    /**
+     * @param mixed $key
+     */
+    private static function validKey($key): bool
+    {
+        if (! is_string($key)) {
+            throw new InvalidArgument(sprintf('Cache key must be string, "%s" given.', is_object($key) ? get_class($key) : gettype($key)));
+        }
+
+        if ($key === '') {
+            throw new InvalidArgument('Cache key length must be greater than zero.');
+        }
+
+        if (strpbrk($key, self::RESERVED_CHARACTERS) !== false) {
+            throw new InvalidArgument(sprintf('Cache key "%s" contains reserved characters "%s".', $key, self::RESERVED_CHARACTERS));
+        }
+
+        return true;
+    }
+
+    /**
+     * @param mixed[] $keys
+     */
+    private static function validKeys(array $keys): bool
+    {
+        foreach ($keys as $key) {
+            self::validKey($key);
+        }
+
+        return true;
+    }
+
+    /**
+     * @param mixed[] $keys
+     */
+    private function doDeleteMultiple(array $keys): bool
+    {
+        if ($this->cache instanceof MultiDeleteCache) {
+            return $this->cache->deleteMultiple($keys);
+        }
+
+        $success = true;
+        foreach ($keys as $key) {
+            $success = $this->cache->delete($key) && $success;
+        }
+
+        return $success;
+    }
+
+    /**
+     * @param mixed[] $keys
+     *
+     * @return mixed[]
+     */
+    private function doFetchMultiple(array $keys): array
+    {
+        if ($this->cache instanceof MultiGetCache) {
+            return $this->cache->fetchMultiple($keys);
+        }
+
+        $values = [];
+        foreach ($keys as $key) {
+            $value = $this->cache->fetch($key);
+            if (! $value) {
+                continue;
+            }
+
+            $values[$key] = $value;
+        }
+
+        return $values;
+    }
+
+    /**
+     * @param mixed[] $keysAndValues
+     */
+    private function doSaveMultiple(array $keysAndValues, int $lifetime = 0): bool
+    {
+        if ($this->cache instanceof MultiPutCache) {
+            return $this->cache->saveMultiple($keysAndValues, $lifetime);
+        }
+
+        $success = true;
+        foreach ($keysAndValues as $key => $value) {
+            $success = $this->cache->save($key, $value, $lifetime) && $success;
+        }
+
+        return $success;
+    }
+}

vendor/doctrine/cache/lib/Doctrine/Common/Cache/Psr6/CacheItem.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Doctrine\Common\Cache\Psr6;
+
+use DateInterval;
+use DateTime;
+use DateTimeInterface;
+use Psr\Cache\CacheItemInterface;
+use TypeError;
+
+use function get_class;
+use function gettype;
+use function is_int;
+use function is_object;
+use function microtime;
+use function sprintf;
+
+final class CacheItem implements CacheItemInterface
+{
+    /** @var string */
+    private $key;
+    /** @var mixed */
+    private $value;
+    /** @var bool */
+    private $isHit;
+    /** @var float|null */
+    private $expiry;
+
+    /**
+     * @internal
+     *
+     * @param mixed $data
+     */
+    public function __construct(string $key, $data, bool $isHit)
+    {
+        $this->key   = $key;
+        $this->value = $data;
+        $this->isHit = $isHit;
+    }
+
+    public function getKey(): string
+    {
+        return $this->key;
+    }
+
+    /**
+     * {@inheritDoc}
+     *
+     * @return mixed
+     */
+    public function get()
+    {
+        return $this->value;
+    }
+
+    public function isHit(): bool
+    {
+        return $this->isHit;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function set($value): self
+    {
+        $this->value = $value;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function expiresAt($expiration): self
+    {
+        if ($expiration === null) {
+            $this->expiry = null;
+        } elseif ($expiration instanceof DateTimeInterface) {
+            $this->expiry = (float) $expiration->format('U.u');
+        } else {
+            throw new TypeError(sprintf(
+                'Expected $expiration to be an instance of DateTimeInterface or null, got %s',
+                is_object($expiration) ? get_class($expiration) : gettype($expiration)
+            ));
+        }
+
+        return $this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function expiresAfter($time): self
+    {
+        if ($time === null) {
+            $this->expiry = null;
+        } elseif ($time instanceof DateInterval) {
+            $this->expiry = microtime(true) + DateTime::createFromFormat('U', 0)->add($time)->format('U.u');
+        } elseif (is_int($time)) {
+            $this->expiry = $time + microtime(true);
+        } else {
+            throw new TypeError(sprintf(
+                'Expected $time to be either an integer, an instance of DateInterval or null, got %s',
+                is_object($time) ? get_class($time) : gettype($time)
+            ));
+        }
+
+        return $this;
+    }
+
+    /**
+     * @internal
+     */
+    public function getExpiry(): ?float
+    {
+        return $this->expiry;
+    }
+}

vendor/doctrine/cache/lib/Doctrine/Common/Cache/Psr6/DoctrineProvider.php

@@ -0,0 +1,135 @@
+<?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 Doctrine\Common\Cache\Psr6;
+
+use Doctrine\Common\Cache\Cache;
+use Doctrine\Common\Cache\CacheProvider;
+use Psr\Cache\CacheItemPoolInterface;
+use Symfony\Component\Cache\Adapter\DoctrineAdapter as SymfonyDoctrineAdapter;
+use Symfony\Contracts\Service\ResetInterface;
+
+use function rawurlencode;
+
+/**
+ * This class was copied from the Symfony Framework, see the original copyright
+ * notice above. The code is distributed subject to the license terms in
+ * https://github.com/symfony/symfony/blob/ff0cf61278982539c49e467db9ab13cbd342f76d/LICENSE
+ */
+final class DoctrineProvider extends CacheProvider
+{
+    /** @var CacheItemPoolInterface */
+    private $pool;
+
+    public static function wrap(CacheItemPoolInterface $pool): Cache
+    {
+        if ($pool instanceof CacheAdapter) {
+            return $pool->getCache();
+        }
+
+        if ($pool instanceof SymfonyDoctrineAdapter) {
+            $getCache = function () {
+                // phpcs:ignore Squiz.Scope.StaticThisUsage.Found
+                return $this->provider;
+            };
+
+            return $getCache->bindTo($pool, SymfonyDoctrineAdapter::class)();
+        }
+
+        return new self($pool);
+    }
+
+    private function __construct(CacheItemPoolInterface $pool)
+    {
+        $this->pool = $pool;
+    }
+
+    /** @internal */
+    public function getPool(): CacheItemPoolInterface
+    {
+        return $this->pool;
+    }
+
+    public function reset(): void
+    {
+        if ($this->pool instanceof ResetInterface) {
+            $this->pool->reset();
+        }
+
+        $this->setNamespace($this->getNamespace());
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    protected function doFetch($id)
+    {
+        $item = $this->pool->getItem(rawurlencode($id));
+
+        return $item->isHit() ? $item->get() : false;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    protected function doContains($id)
+    {
+        return $this->pool->hasItem(rawurlencode($id));
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    protected function doSave($id, $data, $lifeTime = 0)
+    {
+        $item = $this->pool->getItem(rawurlencode($id));
+
+        if (0 < $lifeTime) {
+            $item->expiresAfter($lifeTime);
+        }
+
+        return $this->pool->save($item->set($data));
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    protected function doDelete($id)
+    {
+        return $this->pool->deleteItem(rawurlencode($id));
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return bool
+     */
+    protected function doFlush()
+    {
+        return $this->pool->clear();
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return array|null
+     */
+    protected function doGetStats()
+    {
+        return null;
+    }
+}

vendor/doctrine/cache/lib/Doctrine/Common/Cache/Psr6/InvalidArgument.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Common\Cache\Psr6;
+
+use InvalidArgumentException;
+use Psr\Cache\InvalidArgumentException as PsrInvalidArgumentException;
+
+/**
+ * @internal
+ */
+final class InvalidArgument extends InvalidArgumentException implements PsrInvalidArgumentException
+{
+}

vendor/doctrine/cache/lib/Doctrine/Common/Cache/Psr6/TypedCacheItem.php

@@ -0,0 +1,99 @@
+<?php
+
+namespace Doctrine\Common\Cache\Psr6;
+
+use DateInterval;
+use DateTime;
+use DateTimeInterface;
+use Psr\Cache\CacheItemInterface;
+use TypeError;
+
+use function get_debug_type;
+use function is_int;
+use function microtime;
+use function sprintf;
+
+final class TypedCacheItem implements CacheItemInterface
+{
+    private ?float $expiry = null;
+
+    /**
+     * @internal
+     */
+    public function __construct(
+        private string $key,
+        private mixed $value,
+        private bool $isHit,
+    ) {
+    }
+
+    public function getKey(): string
+    {
+        return $this->key;
+    }
+
+    public function get(): mixed
+    {
+        return $this->value;
+    }
+
+    public function isHit(): bool
+    {
+        return $this->isHit;
+    }
+
+    public function set(mixed $value): static
+    {
+        $this->value = $value;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function expiresAt($expiration): static
+    {
+        if ($expiration === null) {
+            $this->expiry = null;
+        } elseif ($expiration instanceof DateTimeInterface) {
+            $this->expiry = (float) $expiration->format('U.u');
+        } else {
+            throw new TypeError(sprintf(
+                'Expected $expiration to be an instance of DateTimeInterface or null, got %s',
+                get_debug_type($expiration)
+            ));
+        }
+
+        return $this;
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function expiresAfter($time): static
+    {
+        if ($time === null) {
+            $this->expiry = null;
+        } elseif ($time instanceof DateInterval) {
+            $this->expiry = microtime(true) + DateTime::createFromFormat('U', 0)->add($time)->format('U.u');
+        } elseif (is_int($time)) {
+            $this->expiry = $time + microtime(true);
+        } else {
+            throw new TypeError(sprintf(
+                'Expected $time to be either an integer, an instance of DateInterval or null, got %s',
+                get_debug_type($time)
+            ));
+        }
+
+        return $this;
+    }
+
+    /**
+     * @internal
+     */
+    public function getExpiry(): ?float
+    {
+        return $this->expiry;
+    }
+}