default services conflit ?

old.vendor/symfony/psr-http-message-bridge/.github/workflows/ci.yml

@@ -0,0 +1,49 @@
+name: CI
+
+on:
+    pull_request:
+    push:
+
+jobs:
+    test:
+        name: 'Test ${{ matrix.deps }} on PHP ${{ matrix.php }}'
+        runs-on: ubuntu-latest
+
+        strategy:
+            fail-fast: false
+            matrix:
+                php: ['7.1.3', '7.2', '7.3', '7.4', '8.0', '8.1']
+                include:
+                    - php: '7.4'
+                      deps: lowest
+                      deprecations: max[self]=0
+                    - php: '8.0'
+                      deps: highest
+                      deprecations: max[indirect]=5
+
+        steps:
+            - name: Checkout code
+              uses: actions/checkout@v2
+
+            - name: Setup PHP
+              uses: shivammathur/setup-php@v2
+              with:
+                  php-version: '${{ matrix.php }}'
+                  coverage: none
+
+            - name: Configure composer
+              if: "${{ matrix.deps == 'highest' }}"
+              run: composer config minimum-stability dev
+
+            - name: Composer install
+              uses: ramsey/composer-install@v1
+              with:
+                  dependency-versions: '${{ matrix.deps }}'
+
+            - name: Install PHPUnit
+              run: vendor/bin/simple-phpunit install
+
+            - name: Run tests
+              run: vendor/bin/simple-phpunit
+              env:
+                  SYMFONY_DEPRECATIONS_HELPER: '${{ matrix.deprecations }}'

old.vendor/symfony/psr-http-message-bridge/.gitignore

@@ -0,0 +1,6 @@
+vendor/
+composer.lock
+phpunit.xml
+.php_cs.cache
+.phpunit.result.cache
+/Tests/Fixtures/App/var

old.vendor/symfony/psr-http-message-bridge/.php_cs.dist

@@ -0,0 +1,24 @@
+<?php
+
+return PhpCsFixer\Config::create()
+    ->setRules([
+        '@Symfony' => true,
+        '@Symfony:risky' => true,
+        '@PHPUnit48Migration:risky' => true,
+        'php_unit_no_expectation_annotation' => false, // part of `PHPUnitXYMigration:risky` ruleset, to be enabled when PHPUnit 4.x support will be dropped, as we don't want to rewrite exceptions handling twice
+        'array_syntax' => ['syntax' => 'short'],
+        'fopen_flags' => false,
+        'ordered_imports' => true,
+        'protected_to_private' => false,
+        // Part of @Symfony:risky in PHP-CS-Fixer 2.13.0. To be removed from the config file once upgrading
+        'native_function_invocation' => ['include' => ['@compiler_optimized'], 'scope' => 'namespaced'],
+        // Part of future @Symfony ruleset in PHP-CS-Fixer To be removed from the config file once upgrading
+        'phpdoc_types_order' => ['null_adjustment' => 'always_last', 'sort_algorithm' => 'none'],
+    ])
+    ->setRiskyAllowed(true)
+    ->setFinder(
+        PhpCsFixer\Finder::create()
+            ->in(__DIR__)
+            ->name('*.php')
+    )
+;

old.vendor/symfony/psr-http-message-bridge/ArgumentValueResolver/PsrServerRequestResolver.php

@@ -0,0 +1,58 @@
+<?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\Bridge\PsrHttpMessage\ArgumentValueResolver;
+
+use Psr\Http\Message\MessageInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentValueResolverInterface;
+use Symfony\Component\HttpKernel\ControllerMetadata\ArgumentMetadata;
+
+/**
+ * Injects the RequestInterface, MessageInterface or ServerRequestInterface when requested.
+ *
+ * @author Iltar van der Berg <kjarli@gmail.com>
+ * @author Alexander M. Turek <me@derrabus.de>
+ */
+final class PsrServerRequestResolver implements ArgumentValueResolverInterface
+{
+    private const SUPPORTED_TYPES = [
+        ServerRequestInterface::class => true,
+        RequestInterface::class => true,
+        MessageInterface::class => true,
+    ];
+
+    private $httpMessageFactory;
+
+    public function __construct(HttpMessageFactoryInterface $httpMessageFactory)
+    {
+        $this->httpMessageFactory = $httpMessageFactory;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function supports(Request $request, ArgumentMetadata $argument): bool
+    {
+        return self::SUPPORTED_TYPES[$argument->getType()] ?? false;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolve(Request $request, ArgumentMetadata $argument): \Traversable
+    {
+        yield $this->httpMessageFactory->createRequest($request);
+    }
+}

old.vendor/symfony/psr-http-message-bridge/CHANGELOG.md

@@ -0,0 +1,65 @@
+CHANGELOG
+=========
+
+# 2.1.2 (2021-11-05)
+
+* Allow Symfony 6
+
+# 2.1.0 (2021-02-17)
+
+  * Added a `PsrResponseListener` to automatically convert PSR-7 responses returned by controllers
+  * Added a `PsrServerRequestResolver` that allows injecting PSR-7 request objects into controllers
+
+# 2.0.2 (2020-09-29)
+
+  * Fix populating server params from URI in HttpFoundationFactory
+  * Create cookies as raw in HttpFoundationFactory
+  * Fix BinaryFileResponse with Content-Range PsrHttpFactory
+
+# 2.0.1 (2020-06-25)
+
+  * Don't normalize query string in PsrHttpFactory
+  * Fix conversion for HTTPS requests
+  * Fix populating default port and headers in HttpFoundationFactory
+
+# 2.0.0 (2020-01-02)
+
+  * Remove DiactorosFactory
+
+# 1.3.0 (2019-11-25)
+
+  * Added support for streamed requests
+  * Added support for Symfony 5.0+
+  * Fixed bridging UploadedFile objects
+  * Bumped minimum version of Symfony to 4.4
+
+# 1.2.0 (2019-03-11)
+
+  * Added new documentation links
+  * Bumped minimum version of PHP to 7.1
+  * Added support for streamed responses
+
+# 1.1.2 (2019-04-03)
+
+  * Fixed createResponse
+
+# 1.1.1 (2019-03-11)
+
+  * Deprecated DiactorosFactory, use PsrHttpFactory instead
+  * Removed triggering of deprecation
+
+# 1.1.0 (2018-08-30)
+
+  * Added support for creating PSR-7 messages using PSR-17 factories
+
+# 1.0.2 (2017-12-19)
+
+  * Fixed request target in PSR7 Request (mtibben)
+
+# 1.0.1 (2017-12-04)
+
+  * Added support for Symfony 4 (dunglas)
+
+# 1.0.0 (2016-09-14)
+
+  * Initial release

old.vendor/symfony/psr-http-message-bridge/EventListener/PsrResponseListener.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Symfony\Bridge\PsrHttpMessage\EventListener;
+
+use Psr\Http\Message\ResponseInterface;
+use Symfony\Bridge\PsrHttpMessage\Factory\HttpFoundationFactory;
+use Symfony\Bridge\PsrHttpMessage\HttpFoundationFactoryInterface;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpKernel\Event\ViewEvent;
+use Symfony\Component\HttpKernel\KernelEvents;
+
+/**
+ * Converts PSR-7 Response to HttpFoundation Response using the bridge.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ * @author Alexander M. Turek <me@derrabus.de>
+ */
+final class PsrResponseListener implements EventSubscriberInterface
+{
+    private $httpFoundationFactory;
+
+    public function __construct(HttpFoundationFactoryInterface $httpFoundationFactory = null)
+    {
+        $this->httpFoundationFactory = $httpFoundationFactory ?? new HttpFoundationFactory();
+    }
+
+    /**
+     * Do the conversion if applicable and update the response of the event.
+     */
+    public function onKernelView(ViewEvent $event): void
+    {
+        $controllerResult = $event->getControllerResult();
+
+        if (!$controllerResult instanceof ResponseInterface) {
+            return;
+        }
+
+        $event->setResponse($this->httpFoundationFactory->createResponse($controllerResult));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public static function getSubscribedEvents(): array
+    {
+        return [
+            KernelEvents::VIEW => 'onKernelView',
+        ];
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Factory/HttpFoundationFactory.php

@@ -0,0 +1,248 @@
+<?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\Bridge\PsrHttpMessage\Factory;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UploadedFileInterface;
+use Psr\Http\Message\UriInterface;
+use Symfony\Bridge\PsrHttpMessage\HttpFoundationFactoryInterface;
+use Symfony\Component\HttpFoundation\Cookie;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+
+/**
+ * {@inheritdoc}
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class HttpFoundationFactory implements HttpFoundationFactoryInterface
+{
+    /**
+     * @var int The maximum output buffering size for each iteration when sending the response
+     */
+    private $responseBufferMaxLength;
+
+    public function __construct(int $responseBufferMaxLength = 16372)
+    {
+        $this->responseBufferMaxLength = $responseBufferMaxLength;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createRequest(ServerRequestInterface $psrRequest, bool $streamed = false)
+    {
+        $server = [];
+        $uri = $psrRequest->getUri();
+
+        if ($uri instanceof UriInterface) {
+            $server['SERVER_NAME'] = $uri->getHost();
+            $server['SERVER_PORT'] = $uri->getPort() ?: ('https' === $uri->getScheme() ? 443 : 80);
+            $server['REQUEST_URI'] = $uri->getPath();
+            $server['QUERY_STRING'] = $uri->getQuery();
+
+            if ('' !== $server['QUERY_STRING']) {
+                $server['REQUEST_URI'] .= '?'.$server['QUERY_STRING'];
+            }
+
+            if ('https' === $uri->getScheme()) {
+                $server['HTTPS'] = 'on';
+            }
+        }
+
+        $server['REQUEST_METHOD'] = $psrRequest->getMethod();
+
+        $server = array_replace($psrRequest->getServerParams(), $server);
+
+        $parsedBody = $psrRequest->getParsedBody();
+        $parsedBody = \is_array($parsedBody) ? $parsedBody : [];
+
+        $request = new Request(
+            $psrRequest->getQueryParams(),
+            $parsedBody,
+            $psrRequest->getAttributes(),
+            $psrRequest->getCookieParams(),
+            $this->getFiles($psrRequest->getUploadedFiles()),
+            $server,
+            $streamed ? $psrRequest->getBody()->detach() : $psrRequest->getBody()->__toString()
+        );
+        $request->headers->add($psrRequest->getHeaders());
+
+        return $request;
+    }
+
+    /**
+     * Converts to the input array to $_FILES structure.
+     */
+    private function getFiles(array $uploadedFiles): array
+    {
+        $files = [];
+
+        foreach ($uploadedFiles as $key => $value) {
+            if ($value instanceof UploadedFileInterface) {
+                $files[$key] = $this->createUploadedFile($value);
+            } else {
+                $files[$key] = $this->getFiles($value);
+            }
+        }
+
+        return $files;
+    }
+
+    /**
+     * Creates Symfony UploadedFile instance from PSR-7 ones.
+     */
+    private function createUploadedFile(UploadedFileInterface $psrUploadedFile): UploadedFile
+    {
+        return new UploadedFile($psrUploadedFile, function () { return $this->getTemporaryPath(); });
+    }
+
+    /**
+     * Gets a temporary file path.
+     *
+     * @return string
+     */
+    protected function getTemporaryPath()
+    {
+        return tempnam(sys_get_temp_dir(), uniqid('symfony', true));
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createResponse(ResponseInterface $psrResponse, bool $streamed = false)
+    {
+        $cookies = $psrResponse->getHeader('Set-Cookie');
+        $psrResponse = $psrResponse->withoutHeader('Set-Cookie');
+
+        if ($streamed) {
+            $response = new StreamedResponse(
+                $this->createStreamedResponseCallback($psrResponse->getBody()),
+                $psrResponse->getStatusCode(),
+                $psrResponse->getHeaders()
+            );
+        } else {
+            $response = new Response(
+                $psrResponse->getBody()->__toString(),
+                $psrResponse->getStatusCode(),
+                $psrResponse->getHeaders()
+            );
+        }
+
+        $response->setProtocolVersion($psrResponse->getProtocolVersion());
+
+        foreach ($cookies as $cookie) {
+            $response->headers->setCookie($this->createCookie($cookie));
+        }
+
+        return $response;
+    }
+
+    /**
+     * Creates a Cookie instance from a cookie string.
+     *
+     * Some snippets have been taken from the Guzzle project: https://github.com/guzzle/guzzle/blob/5.3/src/Cookie/SetCookie.php#L34
+     *
+     * @throws \InvalidArgumentException
+     */
+    private function createCookie(string $cookie): Cookie
+    {
+        foreach (explode(';', $cookie) as $part) {
+            $part = trim($part);
+
+            $data = explode('=', $part, 2);
+            $name = $data[0];
+            $value = isset($data[1]) ? trim($data[1], " \n\r\t\0\x0B\"") : null;
+
+            if (!isset($cookieName)) {
+                $cookieName = $name;
+                $cookieValue = $value;
+
+                continue;
+            }
+
+            if ('expires' === strtolower($name) && null !== $value) {
+                $cookieExpire = new \DateTime($value);
+
+                continue;
+            }
+
+            if ('path' === strtolower($name) && null !== $value) {
+                $cookiePath = $value;
+
+                continue;
+            }
+
+            if ('domain' === strtolower($name) && null !== $value) {
+                $cookieDomain = $value;
+
+                continue;
+            }
+
+            if ('secure' === strtolower($name)) {
+                $cookieSecure = true;
+
+                continue;
+            }
+
+            if ('httponly' === strtolower($name)) {
+                $cookieHttpOnly = true;
+
+                continue;
+            }
+
+            if ('samesite' === strtolower($name) && null !== $value) {
+                $samesite = $value;
+
+                continue;
+            }
+        }
+
+        if (!isset($cookieName)) {
+            throw new \InvalidArgumentException('The value of the Set-Cookie header is malformed.');
+        }
+
+        return new Cookie(
+            $cookieName,
+            $cookieValue,
+            isset($cookieExpire) ? $cookieExpire : 0,
+            isset($cookiePath) ? $cookiePath : '/',
+            isset($cookieDomain) ? $cookieDomain : null,
+            isset($cookieSecure),
+            isset($cookieHttpOnly),
+            true,
+            isset($samesite) ? $samesite : null
+        );
+    }
+
+    private function createStreamedResponseCallback(StreamInterface $body): callable
+    {
+        return function () use ($body) {
+            if ($body->isSeekable()) {
+                $body->rewind();
+            }
+
+            if (!$body->isReadable()) {
+                echo $body;
+
+                return;
+            }
+
+            while (!$body->eof()) {
+                echo $body->read($this->responseBufferMaxLength);
+            }
+        };
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Factory/PsrHttpFactory.php

@@ -0,0 +1,171 @@
+<?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\Bridge\PsrHttpMessage\Factory;
+
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Http\Message\UploadedFileInterface;
+use Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface;
+use Symfony\Component\HttpFoundation\BinaryFileResponse;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+
+/**
+ * Builds Psr\HttpMessage instances using a PSR-17 implementation.
+ *
+ * @author Antonio J. García Lagar <aj@garcialagar.es>
+ */
+class PsrHttpFactory implements HttpMessageFactoryInterface
+{
+    private $serverRequestFactory;
+    private $streamFactory;
+    private $uploadedFileFactory;
+    private $responseFactory;
+
+    public function __construct(ServerRequestFactoryInterface $serverRequestFactory, StreamFactoryInterface $streamFactory, UploadedFileFactoryInterface $uploadedFileFactory, ResponseFactoryInterface $responseFactory)
+    {
+        $this->serverRequestFactory = $serverRequestFactory;
+        $this->streamFactory = $streamFactory;
+        $this->uploadedFileFactory = $uploadedFileFactory;
+        $this->responseFactory = $responseFactory;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createRequest(Request $symfonyRequest)
+    {
+        $uri = $symfonyRequest->server->get('QUERY_STRING', '');
+        $uri = $symfonyRequest->getSchemeAndHttpHost().$symfonyRequest->getBaseUrl().$symfonyRequest->getPathInfo().('' !== $uri ? '?'.$uri : '');
+
+        $request = $this->serverRequestFactory->createServerRequest(
+            $symfonyRequest->getMethod(),
+            $uri,
+            $symfonyRequest->server->all()
+        );
+
+        foreach ($symfonyRequest->headers->all() as $name => $value) {
+            $request = $request->withHeader($name, $value);
+        }
+
+        $body = $this->streamFactory->createStreamFromResource($symfonyRequest->getContent(true));
+
+        $request = $request
+            ->withBody($body)
+            ->withUploadedFiles($this->getFiles($symfonyRequest->files->all()))
+            ->withCookieParams($symfonyRequest->cookies->all())
+            ->withQueryParams($symfonyRequest->query->all())
+            ->withParsedBody($symfonyRequest->request->all())
+        ;
+
+        foreach ($symfonyRequest->attributes->all() as $key => $value) {
+            $request = $request->withAttribute($key, $value);
+        }
+
+        return $request;
+    }
+
+    /**
+     * Converts Symfony uploaded files array to the PSR one.
+     *
+     * @return array
+     */
+    private function getFiles(array $uploadedFiles)
+    {
+        $files = [];
+
+        foreach ($uploadedFiles as $key => $value) {
+            if (null === $value) {
+                $files[$key] = $this->uploadedFileFactory->createUploadedFile($this->streamFactory->createStream(), 0, \UPLOAD_ERR_NO_FILE);
+                continue;
+            }
+            if ($value instanceof UploadedFile) {
+                $files[$key] = $this->createUploadedFile($value);
+            } else {
+                $files[$key] = $this->getFiles($value);
+            }
+        }
+
+        return $files;
+    }
+
+    /**
+     * Creates a PSR-7 UploadedFile instance from a Symfony one.
+     *
+     * @return UploadedFileInterface
+     */
+    private function createUploadedFile(UploadedFile $symfonyUploadedFile)
+    {
+        return $this->uploadedFileFactory->createUploadedFile(
+            $this->streamFactory->createStreamFromFile(
+                $symfonyUploadedFile->getRealPath()
+            ),
+            (int) $symfonyUploadedFile->getSize(),
+            $symfonyUploadedFile->getError(),
+            $symfonyUploadedFile->getClientOriginalName(),
+            $symfonyUploadedFile->getClientMimeType()
+        );
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createResponse(Response $symfonyResponse)
+    {
+        $response = $this->responseFactory->createResponse($symfonyResponse->getStatusCode(), Response::$statusTexts[$symfonyResponse->getStatusCode()] ?? '');
+
+        if ($symfonyResponse instanceof BinaryFileResponse && !$symfonyResponse->headers->has('Content-Range')) {
+            $stream = $this->streamFactory->createStreamFromFile(
+                $symfonyResponse->getFile()->getPathname()
+            );
+        } else {
+            $stream = $this->streamFactory->createStreamFromFile('php://temp', 'wb+');
+            if ($symfonyResponse instanceof StreamedResponse || $symfonyResponse instanceof BinaryFileResponse) {
+                ob_start(function ($buffer) use ($stream) {
+                    $stream->write($buffer);
+
+                    return '';
+                });
+
+                $symfonyResponse->sendContent();
+                ob_end_clean();
+            } else {
+                $stream->write($symfonyResponse->getContent());
+            }
+        }
+
+        $response = $response->withBody($stream);
+
+        $headers = $symfonyResponse->headers->all();
+        $cookies = $symfonyResponse->headers->getCookies();
+        if (!empty($cookies)) {
+            $headers['Set-Cookie'] = [];
+
+            foreach ($cookies as $cookie) {
+                $headers['Set-Cookie'][] = $cookie->__toString();
+            }
+        }
+
+        foreach ($headers as $name => $value) {
+            $response = $response->withHeader($name, $value);
+        }
+
+        $protocolVersion = $symfonyResponse->getProtocolVersion();
+        $response = $response->withProtocolVersion($protocolVersion);
+
+        return $response;
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Factory/UploadedFile.php

@@ -0,0 +1,73 @@
+<?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\Bridge\PsrHttpMessage\Factory;
+
+use Psr\Http\Message\UploadedFileInterface;
+use Symfony\Component\HttpFoundation\File\Exception\FileException;
+use Symfony\Component\HttpFoundation\File\File;
+use Symfony\Component\HttpFoundation\File\UploadedFile as BaseUploadedFile;
+
+/**
+ * @author Nicolas Grekas <p@tchwork.com>
+ */
+class UploadedFile extends BaseUploadedFile
+{
+    private $psrUploadedFile;
+    private $test = false;
+
+    public function __construct(UploadedFileInterface $psrUploadedFile, callable $getTemporaryPath)
+    {
+        $error = $psrUploadedFile->getError();
+        $path = '';
+
+        if (\UPLOAD_ERR_NO_FILE !== $error) {
+            $path = $psrUploadedFile->getStream()->getMetadata('uri') ?? '';
+
+            if ($this->test = !\is_string($path) || !is_uploaded_file($path)) {
+                $path = $getTemporaryPath();
+                $psrUploadedFile->moveTo($path);
+            }
+        }
+
+        parent::__construct(
+            $path,
+            (string) $psrUploadedFile->getClientFilename(),
+            $psrUploadedFile->getClientMediaType(),
+            $psrUploadedFile->getError(),
+            $this->test
+        );
+
+        $this->psrUploadedFile = $psrUploadedFile;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function move($directory, $name = null): File
+    {
+        if (!$this->isValid() || $this->test) {
+            return parent::move($directory, $name);
+        }
+
+        $target = $this->getTargetFile($directory, $name);
+
+        try {
+            $this->psrUploadedFile->moveTo($target);
+        } catch (\RuntimeException $e) {
+            throw new FileException(sprintf('Could not move the file "%s" to "%s" (%s)', $this->getPathname(), $target, $e->getMessage()), 0, $e);
+        }
+
+        @chmod($target, 0666 & ~umask());
+
+        return $target;
+    }
+}

old.vendor/symfony/psr-http-message-bridge/HttpFoundationFactoryInterface.php

@@ -0,0 +1,39 @@
+<?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\Bridge\PsrHttpMessage;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Creates Symfony Request and Response instances from PSR-7 ones.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+interface HttpFoundationFactoryInterface
+{
+    /**
+     * Creates a Symfony Request instance from a PSR-7 one.
+     *
+     * @return Request
+     */
+    public function createRequest(ServerRequestInterface $psrRequest, bool $streamed = false);
+
+    /**
+     * Creates a Symfony Response instance from a PSR-7 one.
+     *
+     * @return Response
+     */
+    public function createResponse(ResponseInterface $psrResponse, bool $streamed = false);
+}

old.vendor/symfony/psr-http-message-bridge/HttpMessageFactoryInterface.php

@@ -0,0 +1,39 @@
+<?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\Bridge\PsrHttpMessage;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Creates PSR HTTP Request and Response instances from Symfony ones.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+interface HttpMessageFactoryInterface
+{
+    /**
+     * Creates a PSR-7 Request instance from a Symfony one.
+     *
+     * @return ServerRequestInterface
+     */
+    public function createRequest(Request $symfonyRequest);
+
+    /**
+     * Creates a PSR-7 Response instance from a Symfony one.
+     *
+     * @return ResponseInterface
+     */
+    public function createResponse(Response $symfonyResponse);
+}

old.vendor/symfony/psr-http-message-bridge/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2004-2021 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.

old.vendor/symfony/psr-http-message-bridge/README.md

@@ -0,0 +1,19 @@
+PSR-7 Bridge
+============
+
+Provides integration for PSR7.
+
+Resources
+---------
+
+  * [Documentation](https://symfony.com/doc/current/components/psr7.html)
+
+Running the tests
+-----------------
+
+If you want to run the unit tests, install dev dependencies before
+running PHPUnit:
+
+    $ cd path/to/Symfony/Bridge/PsrHttpMessage/
+    $ composer.phar install
+    $ phpunit

old.vendor/symfony/psr-http-message-bridge/Tests/ArgumentValueResolver/PsrServerRequestResolverTest.php

@@ -0,0 +1,68 @@
+<?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\Bridge\PsrHttpMessage\Tests\ArgumentValueResolver;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Message\MessageInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Symfony\Bridge\PsrHttpMessage\ArgumentValueResolver\PsrServerRequestResolver;
+use Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Controller\ArgumentResolver;
+
+/**
+ * @author Alexander M. Turek <me@derrabus.de>
+ */
+final class PsrServerRequestResolverTest extends TestCase
+{
+    public function testServerRequest()
+    {
+        $symfonyRequest = $this->createMock(Request::class);
+        $psrRequest = $this->createMock(ServerRequestInterface::class);
+
+        $resolver = $this->bootstrapResolver($symfonyRequest, $psrRequest);
+
+        self::assertSame([$psrRequest], $resolver->getArguments($symfonyRequest, static function (ServerRequestInterface $serverRequest): void {}));
+    }
+
+    public function testRequest()
+    {
+        $symfonyRequest = $this->createMock(Request::class);
+        $psrRequest = $this->createMock(ServerRequestInterface::class);
+
+        $resolver = $this->bootstrapResolver($symfonyRequest, $psrRequest);
+
+        self::assertSame([$psrRequest], $resolver->getArguments($symfonyRequest, static function (RequestInterface $request): void {}));
+    }
+
+    public function testMessage()
+    {
+        $symfonyRequest = $this->createMock(Request::class);
+        $psrRequest = $this->createMock(ServerRequestInterface::class);
+
+        $resolver = $this->bootstrapResolver($symfonyRequest, $psrRequest);
+
+        self::assertSame([$psrRequest], $resolver->getArguments($symfonyRequest, static function (MessageInterface $request): void {}));
+    }
+
+    private function bootstrapResolver(Request $symfonyRequest, ServerRequestInterface $psrRequest): ArgumentResolver
+    {
+        $messageFactory = $this->createMock(HttpMessageFactoryInterface::class);
+        $messageFactory->expects(self::once())
+            ->method('createRequest')
+            ->with(self::identicalTo($symfonyRequest))
+            ->willReturn($psrRequest);
+
+        return new ArgumentResolver(null, [new PsrServerRequestResolver($messageFactory)]);
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/EventListener/PsrResponseListenerTest.php

@@ -0,0 +1,53 @@
+<?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\Bridge\PsrHttpMessage\Tests\EventListener;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Bridge\PsrHttpMessage\EventListener\PsrResponseListener;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\Response;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpKernel\Event\ViewEvent;
+use Symfony\Component\HttpKernel\HttpKernelInterface;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class PsrResponseListenerTest extends TestCase
+{
+    public function testConvertsControllerResult()
+    {
+        $listener = new PsrResponseListener();
+        $event = $this->createEventMock(new Response());
+        $listener->onKernelView($event);
+
+        self::assertTrue($event->hasResponse());
+    }
+
+    public function testDoesNotConvertControllerResult()
+    {
+        $listener = new PsrResponseListener();
+        $event = $this->createEventMock([]);
+
+        $listener->onKernelView($event);
+        self::assertFalse($event->hasResponse());
+
+        $event = $this->createEventMock(null);
+
+        $listener->onKernelView($event);
+        self::assertFalse($event->hasResponse());
+    }
+
+    private function createEventMock($controllerResult): ViewEvent
+    {
+        return new ViewEvent($this->createMock(HttpKernelInterface::class), new Request(), HttpKernelInterface::MASTER_REQUEST, $controllerResult);
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Factory/AbstractHttpMessageFactoryTest.php

@@ -0,0 +1,234 @@
+<?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\Bridge\PsrHttpMessage\Tests\Factory;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface;
+use Symfony\Component\HttpFoundation\BinaryFileResponse;
+use Symfony\Component\HttpFoundation\Cookie;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ * @author Antonio J. García Lagar <aj@garcialagar.es>
+ */
+abstract class AbstractHttpMessageFactoryTest extends TestCase
+{
+    private $factory;
+    private $tmpDir;
+
+    abstract protected function buildHttpMessageFactory(): HttpMessageFactoryInterface;
+
+    protected function setUp(): void
+    {
+        $this->factory = $this->buildHttpMessageFactory();
+        $this->tmpDir = sys_get_temp_dir();
+    }
+
+    public function testCreateRequest()
+    {
+        $stdClass = new \stdClass();
+        $request = new Request(
+            [
+                'bar' => ['baz' => '42'],
+                'foo' => '1',
+            ],
+            [
+                'twitter' => [
+                    '@dunglas' => 'Kévin Dunglas',
+                    '@coopTilleuls' => 'Les-Tilleuls.coop',
+                ],
+                'baz' => '2',
+            ],
+            [
+                'a1' => $stdClass,
+                'a2' => ['foo' => 'bar'],
+            ],
+            [
+                'c1' => 'foo',
+                'c2' => ['c3' => 'bar'],
+            ],
+            [
+                'f1' => $this->createUploadedFile('F1', 'f1.txt', 'text/plain', \UPLOAD_ERR_OK),
+                'foo' => ['f2' => $this->createUploadedFile('F2', 'f2.txt', 'text/plain', \UPLOAD_ERR_OK)],
+            ],
+            [
+                'REQUEST_METHOD' => 'POST',
+                'HTTP_HOST' => 'dunglas.fr',
+                'HTTP_X_SYMFONY' => '2.8',
+                'REQUEST_URI' => '/testCreateRequest?bar[baz]=42&foo=1',
+                'QUERY_STRING' => 'bar[baz]=42&foo=1',
+            ],
+            'Content'
+        );
+
+        $psrRequest = $this->factory->createRequest($request);
+
+        $this->assertEquals('Content', $psrRequest->getBody()->__toString());
+
+        $queryParams = $psrRequest->getQueryParams();
+        $this->assertEquals('1', $queryParams['foo']);
+        $this->assertEquals('42', $queryParams['bar']['baz']);
+
+        $requestTarget = $psrRequest->getRequestTarget();
+        $this->assertEquals('/testCreateRequest?bar[baz]=42&foo=1', urldecode($requestTarget));
+
+        $parsedBody = $psrRequest->getParsedBody();
+        $this->assertEquals('Kévin Dunglas', $parsedBody['twitter']['@dunglas']);
+        $this->assertEquals('Les-Tilleuls.coop', $parsedBody['twitter']['@coopTilleuls']);
+        $this->assertEquals('2', $parsedBody['baz']);
+
+        $attributes = $psrRequest->getAttributes();
+        $this->assertEquals($stdClass, $attributes['a1']);
+        $this->assertEquals('bar', $attributes['a2']['foo']);
+
+        $cookies = $psrRequest->getCookieParams();
+        $this->assertEquals('foo', $cookies['c1']);
+        $this->assertEquals('bar', $cookies['c2']['c3']);
+
+        $uploadedFiles = $psrRequest->getUploadedFiles();
+        $this->assertEquals('F1', $uploadedFiles['f1']->getStream()->__toString());
+        $this->assertEquals('f1.txt', $uploadedFiles['f1']->getClientFilename());
+        $this->assertEquals('text/plain', $uploadedFiles['f1']->getClientMediaType());
+        $this->assertEquals(\UPLOAD_ERR_OK, $uploadedFiles['f1']->getError());
+
+        $this->assertEquals('F2', $uploadedFiles['foo']['f2']->getStream()->__toString());
+        $this->assertEquals('f2.txt', $uploadedFiles['foo']['f2']->getClientFilename());
+        $this->assertEquals('text/plain', $uploadedFiles['foo']['f2']->getClientMediaType());
+        $this->assertEquals(\UPLOAD_ERR_OK, $uploadedFiles['foo']['f2']->getError());
+
+        $serverParams = $psrRequest->getServerParams();
+        $this->assertEquals('POST', $serverParams['REQUEST_METHOD']);
+        $this->assertEquals('2.8', $serverParams['HTTP_X_SYMFONY']);
+        $this->assertEquals('POST', $psrRequest->getMethod());
+        $this->assertEquals(['2.8'], $psrRequest->getHeader('X-Symfony'));
+    }
+
+    public function testGetContentCanBeCalledAfterRequestCreation()
+    {
+        $header = ['HTTP_HOST' => 'dunglas.fr'];
+        $request = new Request([], [], [], [], [], $header, 'Content');
+
+        $psrRequest = $this->factory->createRequest($request);
+
+        $this->assertEquals('Content', $psrRequest->getBody()->__toString());
+        $this->assertEquals('Content', $request->getContent());
+    }
+
+    private function createUploadedFile($content, $originalName, $mimeType, $error)
+    {
+        $path = tempnam($this->tmpDir, uniqid());
+        file_put_contents($path, $content);
+
+        return new UploadedFile($path, $originalName, $mimeType, $error, true);
+    }
+
+    public function testCreateResponse()
+    {
+        $response = new Response(
+            'Response content.',
+            202,
+            ['X-Symfony' => ['3.4']]
+        );
+        $response->headers->setCookie(new Cookie('city', 'Lille', new \DateTime('Wed, 13 Jan 2021 22:23:01 GMT'), '/', null, false, true, false, 'lax'));
+
+        $psrResponse = $this->factory->createResponse($response);
+        $this->assertEquals('Response content.', $psrResponse->getBody()->__toString());
+        $this->assertEquals(202, $psrResponse->getStatusCode());
+        $this->assertEquals(['3.4'], $psrResponse->getHeader('X-Symfony'));
+
+        $cookieHeader = $psrResponse->getHeader('Set-Cookie');
+        $this->assertIsArray($cookieHeader);
+        $this->assertCount(1, $cookieHeader);
+        $this->assertMatchesRegularExpression('{city=Lille; expires=Wed, 13-Jan-2021 22:23:01 GMT;( max-age=\d+;)? path=/; httponly}i', $cookieHeader[0]);
+    }
+
+    public function testCreateResponseFromStreamed()
+    {
+        $response = new StreamedResponse(function () {
+            echo "Line 1\n";
+            flush();
+
+            echo "Line 2\n";
+            flush();
+        });
+
+        $psrResponse = $this->factory->createResponse($response);
+
+        $this->assertEquals("Line 1\nLine 2\n", $psrResponse->getBody()->__toString());
+    }
+
+    public function testCreateResponseFromBinaryFile()
+    {
+        $path = tempnam($this->tmpDir, uniqid());
+        file_put_contents($path, 'Binary');
+
+        $response = new BinaryFileResponse($path);
+
+        $psrResponse = $this->factory->createResponse($response);
+
+        $this->assertEquals('Binary', $psrResponse->getBody()->__toString());
+    }
+
+    public function testCreateResponseFromBinaryFileWithRange()
+    {
+        $path = tempnam($this->tmpDir, uniqid());
+        file_put_contents($path, 'Binary');
+
+        $request = new Request();
+        $request->headers->set('Range', 'bytes=1-4');
+
+        $response = new BinaryFileResponse($path, 200, ['Content-Type' => 'plain/text']);
+        $response->prepare($request);
+
+        $psrResponse = $this->factory->createResponse($response);
+
+        $this->assertEquals('inar', $psrResponse->getBody()->__toString());
+        $this->assertSame('bytes 1-4/6', $psrResponse->getHeaderLine('Content-Range'));
+    }
+
+    public function testUploadErrNoFile()
+    {
+        $file = new UploadedFile('', '', null, \UPLOAD_ERR_NO_FILE, true);
+
+        $this->assertEquals(0, $file->getSize());
+        $this->assertEquals(\UPLOAD_ERR_NO_FILE, $file->getError());
+        $this->assertFalse($file->getSize(), 'SplFile::getSize() returns false on error');
+
+        $request = new Request(
+            [],
+            [],
+            [],
+            [],
+            [
+            'f1' => $file,
+            'f2' => ['name' => null, 'type' => null, 'tmp_name' => null, 'error' => \UPLOAD_ERR_NO_FILE, 'size' => 0],
+          ],
+            [
+            'REQUEST_METHOD' => 'POST',
+            'HTTP_HOST' => 'dunglas.fr',
+            'HTTP_X_SYMFONY' => '2.8',
+          ],
+            'Content'
+        );
+
+        $psrRequest = $this->factory->createRequest($request);
+
+        $uploadedFiles = $psrRequest->getUploadedFiles();
+
+        $this->assertEquals(\UPLOAD_ERR_NO_FILE, $uploadedFiles['f1']->getError());
+        $this->assertEquals(\UPLOAD_ERR_NO_FILE, $uploadedFiles['f2']->getError());
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Factory/HttpFoundationFactoryTest.php

@@ -0,0 +1,272 @@
+<?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\Bridge\PsrHttpMessage\Tests\Factory;
+
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Message\UploadedFileInterface;
+use Symfony\Bridge\PsrHttpMessage\Factory\HttpFoundationFactory;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\Response;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\ServerRequest;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\Stream;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\UploadedFile;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\Uri;
+use Symfony\Component\HttpFoundation\Cookie;
+use Symfony\Component\HttpFoundation\File\Exception\FileException;
+use Symfony\Component\HttpFoundation\File\UploadedFile as HttpFoundationUploadedFile;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class HttpFoundationFactoryTest extends TestCase
+{
+    /** @var HttpFoundationFactory */
+    private $factory;
+
+    /** @var string */
+    private $tmpDir;
+
+    protected function setUp(): void
+    {
+        $this->factory = new HttpFoundationFactory();
+        $this->tmpDir = sys_get_temp_dir();
+    }
+
+    public function testCreateRequest()
+    {
+        $stdClass = new \stdClass();
+        $serverRequest = new ServerRequest(
+            '1.1',
+            [
+                'X-Dunglas-API-Platform' => '1.0',
+                'X-data' => ['a', 'b'],
+            ],
+            new Stream('The body'),
+            '/about/kevin',
+            'GET',
+            'http://les-tilleuls.coop/about/kevin',
+            ['country' => 'France'],
+            ['city' => 'Lille'],
+            ['url' => 'http://les-tilleuls.coop'],
+            [
+                'doc1' => $this->createUploadedFile('Doc 1', \UPLOAD_ERR_OK, 'doc1.txt', 'text/plain'),
+                'nested' => [
+                    'docs' => [
+                        $this->createUploadedFile('Doc 2', \UPLOAD_ERR_OK, 'doc2.txt', 'text/plain'),
+                        $this->createUploadedFile('Doc 3', \UPLOAD_ERR_OK, 'doc3.txt', 'text/plain'),
+                    ],
+                ],
+            ],
+            ['url' => 'http://dunglas.fr'],
+            ['custom' => $stdClass]
+        );
+
+        $symfonyRequest = $this->factory->createRequest($serverRequest);
+        $files = $symfonyRequest->files->all();
+
+        $this->assertEquals('http://les-tilleuls.coop', $symfonyRequest->query->get('url'));
+        $this->assertEquals('doc1.txt', $files['doc1']->getClientOriginalName());
+        $this->assertEquals('doc2.txt', $files['nested']['docs'][0]->getClientOriginalName());
+        $this->assertEquals('doc3.txt', $files['nested']['docs'][1]->getClientOriginalName());
+        $this->assertEquals('http://dunglas.fr', $symfonyRequest->request->get('url'));
+        $this->assertEquals($stdClass, $symfonyRequest->attributes->get('custom'));
+        $this->assertEquals('Lille', $symfonyRequest->cookies->get('city'));
+        $this->assertEquals('France', $symfonyRequest->server->get('country'));
+        $this->assertEquals('The body', $symfonyRequest->getContent());
+        $this->assertEquals('1.0', $symfonyRequest->headers->get('X-Dunglas-API-Platform'));
+        $this->assertEquals(['a', 'b'], $symfonyRequest->headers->all('X-data'));
+    }
+
+    public function testCreateRequestWithStreamedBody()
+    {
+        $serverRequest = new ServerRequest(
+            '1.1',
+            [],
+            new Stream('The body'),
+            '/',
+            'GET',
+            null,
+            [],
+            [],
+            [],
+            [],
+            null,
+            []
+        );
+
+        $symfonyRequest = $this->factory->createRequest($serverRequest, true);
+        $this->assertEquals('The body', $symfonyRequest->getContent());
+    }
+
+    public function testCreateRequestWithNullParsedBody()
+    {
+        $serverRequest = new ServerRequest(
+            '1.1',
+            [],
+            new Stream(),
+            '/',
+            'GET',
+            null,
+            [],
+            [],
+            [],
+            [],
+            null,
+            []
+        );
+
+        $this->assertCount(0, $this->factory->createRequest($serverRequest)->request);
+    }
+
+    public function testCreateRequestWithObjectParsedBody()
+    {
+        $serverRequest = new ServerRequest(
+            '1.1',
+            [],
+            new Stream(),
+            '/',
+            'GET',
+            null,
+            [],
+            [],
+            [],
+            [],
+            new \stdClass(),
+            []
+        );
+
+        $this->assertCount(0, $this->factory->createRequest($serverRequest)->request);
+    }
+
+    public function testCreateRequestWithUri()
+    {
+        $serverRequest = new ServerRequest(
+            '1.1',
+            [],
+            new Stream(),
+            '/',
+            'GET',
+            new Uri('http://les-tilleuls.coop/about/kevin'),
+            [],
+            [],
+            [],
+            [],
+            null,
+            []
+        );
+
+        $this->assertEquals('/about/kevin', $this->factory->createRequest($serverRequest)->getPathInfo());
+    }
+
+    public function testCreateUploadedFile()
+    {
+        $uploadedFile = $this->createUploadedFile('An uploaded file.', \UPLOAD_ERR_OK, 'myfile.txt', 'text/plain');
+        $symfonyUploadedFile = $this->callCreateUploadedFile($uploadedFile);
+        $size = $symfonyUploadedFile->getSize();
+
+        $uniqid = uniqid();
+        $symfonyUploadedFile->move($this->tmpDir, $uniqid);
+
+        $this->assertEquals($uploadedFile->getSize(), $size);
+        $this->assertEquals(\UPLOAD_ERR_OK, $symfonyUploadedFile->getError());
+        $this->assertEquals('myfile.txt', $symfonyUploadedFile->getClientOriginalName());
+        $this->assertEquals('txt', $symfonyUploadedFile->getClientOriginalExtension());
+        $this->assertEquals('text/plain', $symfonyUploadedFile->getClientMimeType());
+        $this->assertEquals('An uploaded file.', file_get_contents($this->tmpDir.'/'.$uniqid));
+    }
+
+    public function testCreateUploadedFileWithError()
+    {
+        $this->expectException(FileException::class);
+        $this->expectExceptionMessage('The file "e" could not be written on disk.');
+
+        $uploadedFile = $this->createUploadedFile('Error.', \UPLOAD_ERR_CANT_WRITE, 'e', 'text/plain');
+        $symfonyUploadedFile = $this->callCreateUploadedFile($uploadedFile);
+
+        $this->assertEquals(\UPLOAD_ERR_CANT_WRITE, $symfonyUploadedFile->getError());
+
+        $symfonyUploadedFile->move($this->tmpDir, 'shouldFail.txt');
+    }
+
+    private function createUploadedFile($content, $error, $clientFileName, $clientMediaType): UploadedFile
+    {
+        $filePath = tempnam($this->tmpDir, uniqid());
+        file_put_contents($filePath, $content);
+
+        return new UploadedFile($filePath, filesize($filePath), $error, $clientFileName, $clientMediaType);
+    }
+
+    private function callCreateUploadedFile(UploadedFileInterface $uploadedFile): HttpFoundationUploadedFile
+    {
+        $reflection = new \ReflectionClass($this->factory);
+        $createUploadedFile = $reflection->getMethod('createUploadedFile');
+        $createUploadedFile->setAccessible(true);
+
+        return $createUploadedFile->invokeArgs($this->factory, [$uploadedFile]);
+    }
+
+    public function testCreateResponse()
+    {
+        $response = new Response(
+            '1.0',
+            [
+                'X-Symfony' => ['2.8'],
+                'Set-Cookie' => [
+                    'theme=light',
+                    'test',
+                    'ABC=AeD; Domain=dunglas.fr; Path=/kevin; Expires=Wed, 13 Jan 2021 22:23:01 GMT; Secure; HttpOnly; SameSite=Strict',
+                ],
+            ],
+            new Stream('The response body'),
+            200
+        );
+
+        $symfonyResponse = $this->factory->createResponse($response);
+
+        $this->assertEquals('1.0', $symfonyResponse->getProtocolVersion());
+        $this->assertEquals('2.8', $symfonyResponse->headers->get('X-Symfony'));
+
+        $cookies = $symfonyResponse->headers->getCookies();
+        $this->assertEquals('theme', $cookies[0]->getName());
+        $this->assertEquals('light', $cookies[0]->getValue());
+        $this->assertEquals(0, $cookies[0]->getExpiresTime());
+        $this->assertNull($cookies[0]->getDomain());
+        $this->assertEquals('/', $cookies[0]->getPath());
+        $this->assertFalse($cookies[0]->isSecure());
+        $this->assertFalse($cookies[0]->isHttpOnly());
+
+        $this->assertEquals('test', $cookies[1]->getName());
+        $this->assertNull($cookies[1]->getValue());
+
+        $this->assertEquals('ABC', $cookies[2]->getName());
+        $this->assertEquals('AeD', $cookies[2]->getValue());
+        $this->assertEquals(strtotime('Wed, 13 Jan 2021 22:23:01 GMT'), $cookies[2]->getExpiresTime());
+        $this->assertEquals('dunglas.fr', $cookies[2]->getDomain());
+        $this->assertEquals('/kevin', $cookies[2]->getPath());
+        $this->assertTrue($cookies[2]->isSecure());
+        $this->assertTrue($cookies[2]->isHttpOnly());
+        if (\defined('Symfony\Component\HttpFoundation\Cookie::SAMESITE_STRICT')) {
+            $this->assertEquals(Cookie::SAMESITE_STRICT, $cookies[2]->getSameSite());
+        }
+
+        $this->assertEquals('The response body', $symfonyResponse->getContent());
+        $this->assertEquals(200, $symfonyResponse->getStatusCode());
+
+        $symfonyResponse = $this->factory->createResponse($response, true);
+
+        ob_start();
+        $symfonyResponse->sendContent();
+        $sentContent = ob_get_clean();
+
+        $this->assertEquals('The response body', $sentContent);
+        $this->assertEquals(200, $symfonyResponse->getStatusCode());
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Factory/PsrHttpFactoryTest.php

@@ -0,0 +1,30 @@
+<?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\Bridge\PsrHttpMessage\Tests\Factory;
+
+use Nyholm\Psr7\Factory\Psr17Factory;
+use Symfony\Bridge\PsrHttpMessage\Factory\PsrHttpFactory;
+use Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ * @author Antonio J. García Lagar <aj@garcialagar.es>
+ */
+class PsrHttpFactoryTest extends AbstractHttpMessageFactoryTest
+{
+    protected function buildHttpMessageFactory(): HttpMessageFactoryInterface
+    {
+        $factory = new Psr17Factory();
+
+        return new PsrHttpFactory($factory, $factory, $factory, $factory);
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/App/Controller/PsrRequestController.php

@@ -0,0 +1,45 @@
+<?php
+
+namespace Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\App\Controller;
+
+use Psr\Http\Message\MessageInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+
+final class PsrRequestController
+{
+    private $responseFactory;
+    private $streamFactory;
+
+    public function __construct(ResponseFactoryInterface $responseFactory, StreamFactoryInterface $streamFactory)
+    {
+        $this->responseFactory = $responseFactory;
+        $this->streamFactory = $streamFactory;
+    }
+
+    public function serverRequestAction(ServerRequestInterface $request): ResponseInterface
+    {
+        return $this->responseFactory
+            ->createResponse()
+            ->withBody($this->streamFactory->createStream(sprintf('<html><body>%s</body></html>', $request->getMethod())));
+    }
+
+    public function requestAction(RequestInterface $request): ResponseInterface
+    {
+        return $this->responseFactory
+            ->createResponse()
+            ->withStatus(403)
+            ->withBody($this->streamFactory->createStream(sprintf('<html><body>%s %s</body></html>', $request->getMethod(), $request->getBody()->getContents())));
+    }
+
+    public function messageAction(MessageInterface $request): ResponseInterface
+    {
+        return $this->responseFactory
+            ->createResponse()
+            ->withStatus(422)
+            ->withBody($this->streamFactory->createStream(sprintf('<html><body>%s</body></html>', $request->getHeader('X-My-Header')[0])));
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/App/Kernel.php

@@ -0,0 +1,76 @@
+<?php
+
+namespace Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\App;
+
+use Nyholm\Psr7\Factory\Psr17Factory;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Log\NullLogger;
+use Symfony\Bridge\PsrHttpMessage\ArgumentValueResolver\PsrServerRequestResolver;
+use Symfony\Bridge\PsrHttpMessage\EventListener\PsrResponseListener;
+use Symfony\Bridge\PsrHttpMessage\Factory\HttpFoundationFactory;
+use Symfony\Bridge\PsrHttpMessage\Factory\PsrHttpFactory;
+use Symfony\Bridge\PsrHttpMessage\HttpFoundationFactoryInterface;
+use Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\App\Controller\PsrRequestController;
+use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
+use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
+use Symfony\Component\DependencyInjection\Loader\Configurator\ContainerConfigurator;
+use Symfony\Component\HttpKernel\Kernel as SymfonyKernel;
+use Symfony\Component\Routing\Loader\Configurator\RoutingConfigurator;
+
+class Kernel extends SymfonyKernel
+{
+    use MicroKernelTrait;
+
+    public function registerBundles(): iterable
+    {
+        yield new FrameworkBundle();
+    }
+
+    public function getProjectDir(): string
+    {
+        return __DIR__;
+    }
+
+    protected function configureRoutes(RoutingConfigurator $routes): void
+    {
+        $routes
+            ->add('server_request', '/server-request')->controller([PsrRequestController::class, 'serverRequestAction'])->methods(['GET'])
+            ->add('request', '/request')->controller([PsrRequestController::class, 'requestAction'])->methods(['POST'])
+            ->add('message', '/message')->controller([PsrRequestController::class, 'messageAction'])->methods(['PUT'])
+        ;
+    }
+
+    protected function configureContainer(ContainerConfigurator $container): void
+    {
+        $container->extension('framework', [
+            'router' => ['utf8' => true],
+            'secret' => 'for your eyes only',
+            'test' => true,
+        ]);
+
+        $container->services()
+            ->set('nyholm.psr_factory', Psr17Factory::class)
+            ->alias(ResponseFactoryInterface::class, 'nyholm.psr_factory')
+            ->alias(ServerRequestFactoryInterface::class, 'nyholm.psr_factory')
+            ->alias(StreamFactoryInterface::class, 'nyholm.psr_factory')
+            ->alias(UploadedFileFactoryInterface::class, 'nyholm.psr_factory')
+        ;
+
+        $container->services()
+            ->defaults()->autowire()->autoconfigure()
+            ->set(HttpFoundationFactoryInterface::class, HttpFoundationFactory::class)
+            ->set(HttpMessageFactoryInterface::class, PsrHttpFactory::class)
+            ->set(PsrResponseListener::class)
+            ->set(PsrServerRequestResolver::class)
+        ;
+
+        $container->services()
+            ->set('logger', NullLogger::class)
+            ->set(PsrRequestController::class)->public()->autowire()
+        ;
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/App/Kernel44.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\App;
+
+use Nyholm\Psr7\Factory\Psr17Factory;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Log\NullLogger;
+use Symfony\Bridge\PsrHttpMessage\ArgumentValueResolver\PsrServerRequestResolver;
+use Symfony\Bridge\PsrHttpMessage\EventListener\PsrResponseListener;
+use Symfony\Bridge\PsrHttpMessage\Factory\HttpFoundationFactory;
+use Symfony\Bridge\PsrHttpMessage\Factory\PsrHttpFactory;
+use Symfony\Bridge\PsrHttpMessage\HttpFoundationFactoryInterface;
+use Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\App\Controller\PsrRequestController;
+use Symfony\Bundle\FrameworkBundle\FrameworkBundle;
+use Symfony\Bundle\FrameworkBundle\Kernel\MicroKernelTrait;
+use Symfony\Component\Config\Loader\LoaderInterface;
+use Symfony\Component\DependencyInjection\ContainerBuilder;
+use Symfony\Component\HttpKernel\Kernel as SymfonyKernel;
+use Symfony\Component\Routing\RouteCollectionBuilder;
+
+class Kernel44 extends SymfonyKernel
+{
+    use MicroKernelTrait;
+
+    public function registerBundles(): iterable
+    {
+        yield new FrameworkBundle();
+    }
+
+    public function getProjectDir(): string
+    {
+        return __DIR__;
+    }
+
+    protected function configureRoutes(RouteCollectionBuilder $routes): void
+    {
+        $routes->add('/server-request', PsrRequestController::class.'::serverRequestAction')->setMethods(['GET']);
+        $routes->add('/request', PsrRequestController::class.'::requestAction')->setMethods(['POST']);
+        $routes->add('/message', PsrRequestController::class.'::messageAction')->setMethods(['PUT']);
+    }
+
+    protected function configureContainer(ContainerBuilder $container, LoaderInterface $loader): void
+    {
+        $container->loadFromExtension('framework', [
+            'secret' => 'for your eyes only',
+            'test' => true,
+        ]);
+
+        $container->register('nyholm.psr_factory', Psr17Factory::class);
+        $container->setAlias(ResponseFactoryInterface::class, 'nyholm.psr_factory');
+        $container->setAlias(ServerRequestFactoryInterface::class, 'nyholm.psr_factory');
+        $container->setAlias(StreamFactoryInterface::class, 'nyholm.psr_factory');
+        $container->setAlias(UploadedFileFactoryInterface::class, 'nyholm.psr_factory');
+
+        $container->register(HttpFoundationFactoryInterface::class, HttpFoundationFactory::class)->setAutowired(true)->setAutoconfigured(true);
+        $container->register(HttpMessageFactoryInterface::class, PsrHttpFactory::class)->setAutowired(true)->setAutoconfigured(true);
+        $container->register(PsrResponseListener::class)->setAutowired(true)->setAutoconfigured(true);
+        $container->register(PsrServerRequestResolver::class)->setAutowired(true)->setAutoconfigured(true);
+
+        $container->register('logger', NullLogger::class);
+        $container->register(PsrRequestController::class)->setPublic(true)->setAutowired(true);
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/Message.php

@@ -0,0 +1,118 @@
+<?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\Bridge\PsrHttpMessage\Tests\Fixtures;
+
+use Psr\Http\Message\MessageInterface;
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * Message.
+ *
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class Message implements MessageInterface
+{
+    private $version = '1.1';
+    private $headers = [];
+    private $body;
+
+    public function __construct($version = '1.1', array $headers = [], StreamInterface $body = null)
+    {
+        $this->version = $version;
+        $this->headers = $headers;
+        $this->body = $body ?? new Stream();
+    }
+
+    public function getProtocolVersion(): string
+    {
+        return $this->version;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withProtocolVersion($version)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    public function getHeaders(): array
+    {
+        return $this->headers;
+    }
+
+    public function hasHeader($name): bool
+    {
+        return isset($this->headers[$name]);
+    }
+
+    public function getHeader($name): array
+    {
+        return $this->hasHeader($name) ? $this->headers[$name] : [];
+    }
+
+    public function getHeaderLine($name): string
+    {
+        return $this->hasHeader($name) ? implode(',', $this->headers[$name]) : '';
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withHeader($name, $value)
+    {
+        $this->headers[$name] = (array) $value;
+
+        return $this;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withAddedHeader($name, $value)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withoutHeader($name)
+    {
+        unset($this->headers[$name]);
+
+        return $this;
+    }
+
+    public function getBody(): StreamInterface
+    {
+        return $this->body;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withBody(StreamInterface $body)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/Response.php

@@ -0,0 +1,48 @@
+<?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\Bridge\PsrHttpMessage\Tests\Fixtures;
+
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class Response extends Message implements ResponseInterface
+{
+    private $statusCode;
+
+    public function __construct($version = '1.1', array $headers = [], StreamInterface $body = null, $statusCode = 200)
+    {
+        parent::__construct($version, $headers, $body);
+
+        $this->statusCode = $statusCode;
+    }
+
+    public function getStatusCode(): int
+    {
+        return $this->statusCode;
+    }
+
+    /**
+     * @return static
+     */
+    public function withStatus($code, $reasonPhrase = '')
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    public function getReasonPhrase(): string
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/ServerRequest.php

@@ -0,0 +1,202 @@
+<?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\Bridge\PsrHttpMessage\Tests\Fixtures;
+
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UriInterface;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class ServerRequest extends Message implements ServerRequestInterface
+{
+    private $requestTarget;
+    private $method;
+    private $uri;
+    private $server;
+    private $cookies;
+    private $query;
+    private $uploadedFiles;
+    private $data;
+    private $attributes;
+
+    public function __construct($version = '1.1', array $headers = [], StreamInterface $body = null, $requestTarget = '/', $method = 'GET', $uri = null, array $server = [], array $cookies = [], array $query = [], array $uploadedFiles = [], $data = null, array $attributes = [])
+    {
+        parent::__construct($version, $headers, $body);
+
+        $this->requestTarget = $requestTarget;
+        $this->method = $method;
+        $this->uri = $uri;
+        $this->server = $server;
+        $this->cookies = $cookies;
+        $this->query = $query;
+        $this->uploadedFiles = $uploadedFiles;
+        $this->data = $data;
+        $this->attributes = $attributes;
+    }
+
+    public function getRequestTarget(): string
+    {
+        return $this->requestTarget;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withRequestTarget($requestTarget)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    public function getMethod(): string
+    {
+        return $this->method;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withMethod($method)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return UriInterface
+     */
+    public function getUri()
+    {
+        return $this->uri;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withUri(UriInterface $uri, $preserveHost = false)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    public function getServerParams(): array
+    {
+        return $this->server;
+    }
+
+    public function getCookieParams(): array
+    {
+        return $this->cookies;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withCookieParams(array $cookies)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    public function getQueryParams(): array
+    {
+        return $this->query;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withQueryParams(array $query)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    public function getUploadedFiles(): array
+    {
+        return $this->uploadedFiles;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withUploadedFiles(array $uploadedFiles)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return array|object|null
+     */
+    public function getParsedBody()
+    {
+        return $this->data;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withParsedBody($data)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    public function getAttributes(): array
+    {
+        return $this->attributes;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return mixed
+     */
+    public function getAttribute($name, $default = null)
+    {
+        return $this->attributes[$name] ?? $default;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withAttribute($name, $value)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withoutAttribute($name)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/Stream.php

@@ -0,0 +1,108 @@
+<?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\Bridge\PsrHttpMessage\Tests\Fixtures;
+
+use Psr\Http\Message\StreamInterface;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class Stream implements StreamInterface
+{
+    private $stringContent;
+    private $eof = true;
+
+    public function __construct($stringContent = '')
+    {
+        $this->stringContent = $stringContent;
+    }
+
+    public function __toString(): string
+    {
+        return $this->stringContent;
+    }
+
+    public function close(): void
+    {
+    }
+
+    public function detach()
+    {
+        return fopen('data://text/plain,'.$this->stringContent, 'r');
+    }
+
+    public function getSize(): ?int
+    {
+        return null;
+    }
+
+    public function tell(): int
+    {
+        return 0;
+    }
+
+    public function eof(): bool
+    {
+        return $this->eof;
+    }
+
+    public function isSeekable(): bool
+    {
+        return true;
+    }
+
+    public function seek($offset, $whence = \SEEK_SET): void
+    {
+    }
+
+    public function rewind(): void
+    {
+        $this->eof = false;
+    }
+
+    public function isWritable(): bool
+    {
+        return false;
+    }
+
+    public function write($string): int
+    {
+        return \strlen($string);
+    }
+
+    public function isReadable(): bool
+    {
+        return true;
+    }
+
+    public function read($length): string
+    {
+        $this->eof = true;
+
+        return $this->stringContent;
+    }
+
+    public function getContents(): string
+    {
+        return $this->stringContent;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return mixed
+     */
+    public function getMetadata($key = null)
+    {
+        return null;
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/UploadedFile.php

@@ -0,0 +1,65 @@
+<?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\Bridge\PsrHttpMessage\Tests\Fixtures;
+
+use Psr\Http\Message\UploadedFileInterface;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ */
+class UploadedFile implements UploadedFileInterface
+{
+    private $filePath;
+    private $size;
+    private $error;
+    private $clientFileName;
+    private $clientMediaType;
+
+    public function __construct($filePath, $size = null, $error = \UPLOAD_ERR_OK, $clientFileName = null, $clientMediaType = null)
+    {
+        $this->filePath = $filePath;
+        $this->size = $size;
+        $this->error = $error;
+        $this->clientFileName = $clientFileName;
+        $this->clientMediaType = $clientMediaType;
+    }
+
+    public function getStream(): Stream
+    {
+        return new Stream(file_get_contents($this->filePath));
+    }
+
+    public function moveTo($targetPath): void
+    {
+        rename($this->filePath, $targetPath);
+    }
+
+    public function getSize(): ?int
+    {
+        return $this->size;
+    }
+
+    public function getError(): int
+    {
+        return $this->error;
+    }
+
+    public function getClientFilename(): ?string
+    {
+        return $this->clientFileName;
+    }
+
+    public function getClientMediaType(): ?string
+    {
+        return $this->clientMediaType;
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Fixtures/Uri.php

@@ -0,0 +1,170 @@
+<?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\Bridge\PsrHttpMessage\Tests\Fixtures;
+
+use Psr\Http\Message\UriInterface;
+
+/**
+ * @author Rougin Royce Gutib <rougingutib@gmail.com>
+ */
+class Uri implements UriInterface
+{
+    private $scheme = '';
+    private $userInfo = '';
+    private $host = '';
+    private $port;
+    private $path = '';
+    private $query = '';
+    private $fragment = '';
+    private $uriString;
+
+    public function __construct(string $uri = '')
+    {
+        $parts = parse_url($uri);
+
+        $this->scheme = $parts['scheme'] ?? '';
+        $this->userInfo = $parts['user'] ?? '';
+        $this->host = $parts['host'] ?? '';
+        $this->port = $parts['port'] ?? null;
+        $this->path = $parts['path'] ?? '';
+        $this->query = $parts['query'] ?? '';
+        $this->fragment = $parts['fragment'] ?? '';
+        $this->uriString = $uri;
+    }
+
+    public function getScheme(): string
+    {
+        return $this->scheme;
+    }
+
+    public function getAuthority(): string
+    {
+        if (empty($this->host)) {
+            return '';
+        }
+
+        $authority = $this->host;
+
+        if (!empty($this->userInfo)) {
+            $authority = $this->userInfo.'@'.$authority;
+        }
+
+        $authority .= ':'.$this->port;
+
+        return $authority;
+    }
+
+    public function getUserInfo(): string
+    {
+        return $this->userInfo;
+    }
+
+    public function getHost(): string
+    {
+        return $this->host;
+    }
+
+    public function getPort(): ?int
+    {
+        return $this->port;
+    }
+
+    public function getPath(): string
+    {
+        return $this->path;
+    }
+
+    public function getQuery(): string
+    {
+        return $this->query;
+    }
+
+    public function getFragment(): string
+    {
+        return $this->fragment;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withScheme($scheme)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withUserInfo($user, $password = null)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withHost($host)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withPort($port)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withPath($path)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withQuery($query)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @return static
+     */
+    public function withFragment($fragment)
+    {
+        throw new \BadMethodCallException('Not implemented.');
+    }
+
+    public function __toString(): string
+    {
+        return $this->uriString;
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Functional/ControllerTest.php

@@ -0,0 +1,55 @@
+<?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\Bridge\PsrHttpMessage\Tests\Functional;
+
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\App\Kernel;
+use Symfony\Bridge\PsrHttpMessage\Tests\Fixtures\App\Kernel44;
+use Symfony\Bundle\FrameworkBundle\Test\WebTestCase;
+use Symfony\Component\HttpKernel\Kernel as SymfonyKernel;
+
+/**
+ * @author Alexander M. Turek <me@derrabus.de>
+ */
+final class ControllerTest extends WebTestCase
+{
+    public function testServerRequestAction()
+    {
+        $client = self::createClient();
+        $crawler = $client->request('GET', '/server-request');
+
+        self::assertResponseStatusCodeSame(200);
+        self::assertSame('GET', $crawler->text());
+    }
+
+    public function testRequestAction()
+    {
+        $client = self::createClient();
+        $crawler = $client->request('POST', '/request', [], [], [], 'some content');
+
+        self::assertResponseStatusCodeSame(403);
+        self::assertSame('POST some content', $crawler->text());
+    }
+
+    public function testMessageAction()
+    {
+        $client = self::createClient();
+        $crawler = $client->request('PUT', '/message', [], [], ['HTTP_X_MY_HEADER' => 'some content']);
+
+        self::assertResponseStatusCodeSame(422);
+        self::assertSame('some content', $crawler->text());
+    }
+
+    protected static function getKernelClass(): string
+    {
+        return SymfonyKernel::VERSION_ID >= 50200 ? Kernel::class : Kernel44::class;
+    }
+}

old.vendor/symfony/psr-http-message-bridge/Tests/Functional/CovertTest.php

@@ -0,0 +1,237 @@
+<?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\Bridge\PsrHttpMessage\Tests\Functional;
+
+use Nyholm\Psr7\Factory\Psr17Factory;
+use Nyholm\Psr7\Response as Psr7Response;
+use Nyholm\Psr7\ServerRequest as Psr7Request;
+use Nyholm\Psr7\Stream as Psr7Stream;
+use PHPUnit\Framework\TestCase;
+use Psr\Http\Message\ResponseInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Symfony\Bridge\PsrHttpMessage\Factory\HttpFoundationFactory;
+use Symfony\Bridge\PsrHttpMessage\Factory\PsrHttpFactory;
+use Symfony\Bridge\PsrHttpMessage\HttpFoundationFactoryInterface;
+use Symfony\Bridge\PsrHttpMessage\HttpMessageFactoryInterface;
+use Symfony\Component\HttpFoundation\Cookie;
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+use Symfony\Component\HttpFoundation\Request;
+use Symfony\Component\HttpFoundation\Response;
+
+/**
+ * Test to convert a request/response back and forth to make sure we do not loose data.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+class CovertTest extends TestCase
+{
+    protected function setUp(): void
+    {
+        if (!class_exists(Psr7Request::class)) {
+            $this->markTestSkipped('nyholm/psr7 is not installed.');
+        }
+    }
+
+    /**
+     * @dataProvider requestProvider
+     *
+     * @param Request|ServerRequestInterface                             $request
+     * @param HttpFoundationFactoryInterface|HttpMessageFactoryInterface $firstFactory
+     * @param HttpFoundationFactoryInterface|HttpMessageFactoryInterface $secondFactory
+     */
+    public function testConvertRequestMultipleTimes($request, $firstFactory, $secondFactory)
+    {
+        $temporaryRequest = $firstFactory->createRequest($request);
+        $finalRequest = $secondFactory->createRequest($temporaryRequest);
+
+        if ($finalRequest instanceof Request) {
+            $this->assertEquals($request->getBasePath(), $finalRequest->getBasePath());
+            $this->assertEquals($request->getBaseUrl(), $finalRequest->getBaseUrl());
+            $this->assertEquals($request->getContent(), $finalRequest->getContent());
+            $this->assertEquals($request->getEncodings(), $finalRequest->getEncodings());
+            $this->assertEquals($request->getETags(), $finalRequest->getETags());
+            $this->assertEquals($request->getHost(), $finalRequest->getHost());
+            $this->assertEquals($request->getHttpHost(), $finalRequest->getHttpHost());
+            $this->assertEquals($request->getMethod(), $finalRequest->getMethod());
+            $this->assertEquals($request->getPassword(), $finalRequest->getPassword());
+            $this->assertEquals($request->getPathInfo(), $finalRequest->getPathInfo());
+            $this->assertEquals($request->getPort(), $finalRequest->getPort());
+            $this->assertEquals($request->getProtocolVersion(), $finalRequest->getProtocolVersion());
+            $this->assertEquals($request->getQueryString(), $finalRequest->getQueryString());
+            $this->assertEquals($request->getRequestUri(), $finalRequest->getRequestUri());
+            $this->assertEquals($request->getScheme(), $finalRequest->getScheme());
+            $this->assertEquals($request->getSchemeAndHttpHost(), $finalRequest->getSchemeAndHttpHost());
+            $this->assertEquals($request->getScriptName(), $finalRequest->getScriptName());
+            $this->assertEquals($request->getUri(), $finalRequest->getUri());
+            $this->assertEquals($request->getUser(), $finalRequest->getUser());
+            $this->assertEquals($request->getUserInfo(), $finalRequest->getUserInfo());
+        } elseif ($finalRequest instanceof ServerRequestInterface) {
+            $strToLower = function ($arr) {
+                foreach ($arr as $key => $value) {
+                    yield strtolower($key) => $value;
+                }
+            };
+            $this->assertEquals($request->getAttributes(), $finalRequest->getAttributes());
+            $this->assertEquals($request->getCookieParams(), $finalRequest->getCookieParams());
+            $this->assertEquals((array) $request->getParsedBody(), (array) $finalRequest->getParsedBody());
+            $this->assertEquals($request->getQueryParams(), $finalRequest->getQueryParams());
+            // PSR7 does not define a "withServerParams" so this is impossible to implement without knowing the PSR7 implementation.
+            //$this->assertEquals($request->getServerParams(), $finalRequest->getServerParams());
+            $this->assertEquals($request->getUploadedFiles(), $finalRequest->getUploadedFiles());
+            $this->assertEquals($request->getMethod(), $finalRequest->getMethod());
+            $this->assertEquals($request->getRequestTarget(), $finalRequest->getRequestTarget());
+            $this->assertEquals((string) $request->getUri(), (string) $finalRequest->getUri());
+            $this->assertEquals((string) $request->getBody(), (string) $finalRequest->getBody());
+            $this->assertEquals($strToLower($request->getHeaders()), $strToLower($finalRequest->getHeaders()));
+            $this->assertEquals($request->getProtocolVersion(), $finalRequest->getProtocolVersion());
+        } else {
+            $this->fail('$finalRequest must be an instance of PSR7 or a HTTPFoundation request');
+        }
+    }
+
+    public function requestProvider()
+    {
+        $sfRequest = new Request(
+            [
+                'foo' => '1',
+                'bar' => ['baz' => '42'],
+            ],
+            [
+                'twitter' => [
+                    '@dunglas' => 'Kévin Dunglas',
+                    '@coopTilleuls' => 'Les-Tilleuls.coop',
+                ],
+                'baz' => '2',
+            ],
+            [
+                'a2' => ['foo' => 'bar'],
+            ],
+            [
+                'c1' => 'foo',
+                'c2' => ['c3' => 'bar'],
+            ],
+            [
+                'f1' => $this->createUploadedFile('F1', 'f1.txt', 'text/plain', \UPLOAD_ERR_OK),
+                'foo' => ['f2' => $this->createUploadedFile('F2', 'f2.txt', 'text/plain', \UPLOAD_ERR_OK)],
+            ],
+            [
+                'REQUEST_METHOD' => 'POST',
+                'HTTP_HOST' => 'dunglas.fr',
+                'SERVER_NAME' => 'dunglas.fr',
+                'SERVER_PORT' => null,
+                'HTTP_X_SYMFONY' => '2.8',
+                'REQUEST_URI' => '/testCreateRequest?foo=1&bar%5Bbaz%5D=42',
+                'QUERY_STRING' => 'foo=1&bar%5Bbaz%5D=42',
+            ],
+            'Content'
+        );
+
+        $psr7Requests = [
+            (new Psr7Request('POST', 'http://tnyholm.se/foo/?bar=biz'))
+                ->withQueryParams(['bar' => 'biz']),
+            new Psr7Request('GET', 'https://hey-octave.com/'),
+            new Psr7Request('GET', 'https://hey-octave.com:443/'),
+            new Psr7Request('GET', 'https://hey-octave.com:4242/'),
+            new Psr7Request('GET', 'http://hey-octave.com:80/'),
+        ];
+
+        $nyholmFactory = new Psr17Factory();
+        $psr17Factory = new PsrHttpFactory($nyholmFactory, $nyholmFactory, $nyholmFactory, $nyholmFactory);
+        $symfonyFactory = new HttpFoundationFactory();
+
+        return array_merge([
+            [$sfRequest, $psr17Factory, $symfonyFactory],
+        ], array_map(function ($psr7Request) use ($symfonyFactory, $psr17Factory) {
+            return [$psr7Request, $symfonyFactory, $psr17Factory];
+        }, $psr7Requests));
+    }
+
+    /**
+     * @dataProvider responseProvider
+     *
+     * @param Response|ResponseInterface                                 $response
+     * @param HttpFoundationFactoryInterface|HttpMessageFactoryInterface $firstFactory
+     * @param HttpFoundationFactoryInterface|HttpMessageFactoryInterface $secondFactory
+     */
+    public function testConvertResponseMultipleTimes($response, $firstFactory, $secondFactory)
+    {
+        $temporaryResponse = $firstFactory->createResponse($response);
+        $finalResponse = $secondFactory->createResponse($temporaryResponse);
+
+        if ($finalResponse instanceof Response) {
+            $this->assertEquals($response->getAge(), $finalResponse->getAge());
+            $this->assertEquals($response->getCharset(), $finalResponse->getCharset());
+            $this->assertEquals($response->getContent(), $finalResponse->getContent());
+            $this->assertEquals($response->getDate(), $finalResponse->getDate());
+            $this->assertEquals($response->getEtag(), $finalResponse->getEtag());
+            $this->assertEquals($response->getExpires(), $finalResponse->getExpires());
+            $this->assertEquals($response->getLastModified(), $finalResponse->getLastModified());
+            $this->assertEquals($response->getMaxAge(), $finalResponse->getMaxAge());
+            $this->assertEquals($response->getProtocolVersion(), $finalResponse->getProtocolVersion());
+            $this->assertEquals($response->getStatusCode(), $finalResponse->getStatusCode());
+            $this->assertEquals($response->getTtl(), $finalResponse->getTtl());
+        } elseif ($finalResponse instanceof ResponseInterface) {
+            $strToLower = function ($arr) {
+                foreach ($arr as $key => $value) {
+                    yield strtolower($key) => $value;
+                }
+            };
+            $this->assertEquals($response->getStatusCode(), $finalResponse->getStatusCode());
+            $this->assertEquals($response->getReasonPhrase(), $finalResponse->getReasonPhrase());
+            $this->assertEquals((string) $response->getBody(), (string) $finalResponse->getBody());
+            $this->assertEquals($strToLower($response->getHeaders()), $strToLower($finalResponse->getHeaders()));
+            $this->assertEquals($response->getProtocolVersion(), $finalResponse->getProtocolVersion());
+        } else {
+            $this->fail('$finalResponse must be an instance of PSR7 or a HTTPFoundation response');
+        }
+    }
+
+    public function responseProvider()
+    {
+        $sfResponse = new Response(
+            'Response content.',
+            202,
+            ['x-symfony' => ['3.4']]
+        );
+
+        if (method_exists(Cookie::class, 'create')) {
+            $cookie = Cookie::create('city', 'Lille', new \DateTime('Wed, 13 Jan 2021 22:23:01 GMT'));
+        } else {
+            $cookie = new Cookie('city', 'Lille', new \DateTime('Wed, 13 Jan 2021 22:23:01 GMT'));
+        }
+
+        $sfResponse->headers->setCookie($cookie);
+        $body = Psr7Stream::create();
+        $status = 302;
+        $headers = [
+            'location' => ['http://example.com/'],
+        ];
+        $zendResponse = new Psr7Response($status, $headers, $body);
+
+        $nyholmFactory = new Psr17Factory();
+        $psr17Factory = new PsrHttpFactory($nyholmFactory, $nyholmFactory, $nyholmFactory, $nyholmFactory);
+        $symfonyFactory = new HttpFoundationFactory();
+
+        return [
+            [$sfResponse, $psr17Factory, $symfonyFactory],
+            [$zendResponse, $symfonyFactory, $psr17Factory],
+        ];
+    }
+
+    private function createUploadedFile($content, $originalName, $mimeType, $error)
+    {
+        $path = tempnam(sys_get_temp_dir(), uniqid());
+        file_put_contents($path, $content);
+
+        return new UploadedFile($path, $originalName, $mimeType, $error, true);
+    }
+}

old.vendor/symfony/psr-http-message-bridge/composer.json

@@ -0,0 +1,47 @@
+{
+    "name": "symfony/psr-http-message-bridge",
+    "type": "symfony-bridge",
+    "description": "PSR HTTP message bridge",
+    "keywords": ["http", "psr-7", "psr-17", "http-message"],
+    "homepage": "http://symfony.com",
+    "license": "MIT",
+    "authors": [
+        {
+            "name": "Fabien Potencier",
+            "email": "fabien@symfony.com"
+        },
+        {
+            "name": "Symfony Community",
+            "homepage": "http://symfony.com/contributors"
+        }
+    ],
+    "require": {
+        "php": ">=7.1",
+        "psr/http-message": "^1.0",
+        "symfony/http-foundation": "^4.4 || ^5.0 || ^6.0"
+    },
+    "require-dev": {
+        "symfony/browser-kit": "^4.4 || ^5.0 || ^6.0",
+        "symfony/config": "^4.4 || ^5.0 || ^6.0",
+        "symfony/event-dispatcher": "^4.4 || ^5.0 || ^6.0",
+        "symfony/framework-bundle": "^4.4 || ^5.0 || ^6.0",
+        "symfony/http-kernel": "^4.4 || ^5.0 || ^6.0",
+        "symfony/phpunit-bridge": "^5.4@dev || ^6.0",
+        "nyholm/psr7": "^1.1",
+        "psr/log": "^1.1 || ^2 || ^3"
+    },
+    "suggest": {
+        "nyholm/psr7": "For a super lightweight PSR-7/17 implementation"
+    },
+    "autoload": {
+        "psr-4": { "Symfony\\Bridge\\PsrHttpMessage\\": "" },
+        "exclude-from-classmap": [
+            "/Tests/"
+        ]
+    },
+    "extra": {
+        "branch-alias": {
+            "dev-main": "2.1-dev"
+        }
+    }
+}

old.vendor/symfony/psr-http-message-bridge/phpunit.xml.dist

@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<phpunit backupGlobals="false"
+         backupStaticAttributes="false"
+         colors="true"
+         convertErrorsToExceptions="true"
+         convertNoticesToExceptions="true"
+         convertWarningsToExceptions="true"
+         processIsolation="false"
+         stopOnFailure="false"
+         bootstrap="vendor/autoload.php"
+>
+    <testsuites>
+        <testsuite name="Symfony PSR-7 HTTP message Bridge Test Suite">
+            <directory>./Tests/</directory>
+        </testsuite>
+    </testsuites>
+
+    <filter>
+        <whitelist>
+            <directory>./</directory>
+            <exclude>
+                <directory>./Resources</directory>
+                <directory>./Tests</directory>
+                <directory>./vendor</directory>
+            </exclude>
+        </whitelist>
+    </filter>
+</phpunit>