first commit

pma/vendor/slim/psr7/src/Factory/RequestFactory.php

@@ -0,0 +1,73 @@
+<?php
+
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @license https://github.com/slimphp/Slim-Psr7/blob/master/LICENSE.md (MIT License)
+ */
+
+declare(strict_types=1);
+
+namespace Slim\Psr7\Factory;
+
+use InvalidArgumentException;
+use Psr\Http\Message\RequestFactoryInterface;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UriFactoryInterface;
+use Psr\Http\Message\UriInterface;
+use Slim\Psr7\Headers;
+use Slim\Psr7\Request;
+
+use function is_string;
+
+class RequestFactory implements RequestFactoryInterface
+{
+    /**
+     * @var StreamFactoryInterface|StreamFactory
+     */
+    protected $streamFactory;
+
+    /**
+     * @var UriFactoryInterface|UriFactory
+     */
+    protected $uriFactory;
+
+    /**
+     * @param StreamFactoryInterface|null $streamFactory
+     * @param UriFactoryInterface|null    $uriFactory
+     */
+    public function __construct(?StreamFactoryInterface $streamFactory = null, ?UriFactoryInterface $uriFactory = null)
+    {
+        if (!isset($streamFactory)) {
+            $streamFactory = new StreamFactory();
+        }
+
+        if (!isset($uriFactory)) {
+            $uriFactory = new UriFactory();
+        }
+
+        $this->streamFactory = $streamFactory;
+        $this->uriFactory = $uriFactory;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createRequest(string $method, $uri): RequestInterface
+    {
+        if (is_string($uri)) {
+            $uri = $this->uriFactory->createUri($uri);
+        }
+
+        if (!$uri instanceof UriInterface) {
+            throw new InvalidArgumentException(
+                'Parameter 2 of RequestFactory::createRequest() must be a string or a compatible UriInterface.'
+            );
+        }
+
+        $body = $this->streamFactory->createStream();
+
+        return new Request($method, $uri, new Headers(), [], [], $body);
+    }
+}

pma/vendor/slim/psr7/src/Factory/ResponseFactory.php

@@ -0,0 +1,35 @@
+<?php
+
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @license https://github.com/slimphp/Slim-Psr7/blob/master/LICENSE.md (MIT License)
+ */
+
+declare(strict_types=1);
+
+namespace Slim\Psr7\Factory;
+
+use Fig\Http\Message\StatusCodeInterface;
+use Psr\Http\Message\ResponseFactoryInterface;
+use Psr\Http\Message\ResponseInterface;
+use Slim\Psr7\Response;
+
+class ResponseFactory implements ResponseFactoryInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function createResponse(
+        int $code = StatusCodeInterface::STATUS_OK,
+        string $reasonPhrase = ''
+    ): ResponseInterface {
+        $res = new Response($code);
+
+        if ($reasonPhrase !== '') {
+            $res = $res->withStatus($code, $reasonPhrase);
+        }
+
+        return $res;
+    }
+}

pma/vendor/slim/psr7/src/Factory/ServerRequestFactory.php

@@ -0,0 +1,124 @@
+<?php
+
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @license https://github.com/slimphp/Slim-Psr7/blob/master/LICENSE.md (MIT License)
+ */
+
+declare(strict_types=1);
+
+namespace Slim\Psr7\Factory;
+
+use InvalidArgumentException;
+use Psr\Http\Message\ServerRequestFactoryInterface;
+use Psr\Http\Message\ServerRequestInterface;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\UriFactoryInterface;
+use Psr\Http\Message\UriInterface;
+use Slim\Psr7\Cookies;
+use Slim\Psr7\Headers;
+use Slim\Psr7\Request;
+use Slim\Psr7\Stream;
+use Slim\Psr7\UploadedFile;
+
+use function current;
+use function explode;
+use function fopen;
+use function in_array;
+use function is_string;
+
+class ServerRequestFactory implements ServerRequestFactoryInterface
+{
+    /**
+     * @var StreamFactoryInterface|StreamFactory
+     */
+    protected $streamFactory;
+
+    /**
+     * @var UriFactoryInterface|UriFactory
+     */
+    protected $uriFactory;
+
+    /**
+     * @param StreamFactoryInterface|null $streamFactory
+     * @param UriFactoryInterface|null    $uriFactory
+     */
+    public function __construct(?StreamFactoryInterface $streamFactory = null, ?UriFactoryInterface $uriFactory = null)
+    {
+        if (!isset($streamFactory)) {
+            $streamFactory = new StreamFactory();
+        }
+
+        if (!isset($uriFactory)) {
+            $uriFactory = new UriFactory();
+        }
+
+        $this->streamFactory = $streamFactory;
+        $this->uriFactory = $uriFactory;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createServerRequest(string $method, $uri, array $serverParams = []): ServerRequestInterface
+    {
+        if (is_string($uri)) {
+            $uri = $this->uriFactory->createUri($uri);
+        }
+
+        if (!$uri instanceof UriInterface) {
+            throw new InvalidArgumentException('URI must either be string or instance of ' . UriInterface::class);
+        }
+
+        $body = $this->streamFactory->createStream();
+        $headers = new Headers();
+        $cookies = [];
+
+        if (!empty($serverParams)) {
+            $headers = Headers::createFromGlobals();
+            $cookies = Cookies::parseHeader($headers->getHeader('Cookie', []));
+        }
+
+        return new Request($method, $uri, $headers, $cookies, $serverParams, $body);
+    }
+
+    /**
+     * Create new ServerRequest from environment.
+     *
+     * @internal This method is not part of PSR-17
+     *
+     * @return Request
+     */
+    public static function createFromGlobals(): Request
+    {
+        $method = isset($_SERVER['REQUEST_METHOD']) ? $_SERVER['REQUEST_METHOD'] : 'GET';
+        $uri = (new UriFactory())->createFromGlobals($_SERVER);
+
+        $headers = Headers::createFromGlobals();
+        $cookies = Cookies::parseHeader($headers->getHeader('Cookie', []));
+
+        // Cache the php://input stream as it cannot be re-read
+        $cacheResource = fopen('php://temp', 'wb+');
+        $cache = $cacheResource ? new Stream($cacheResource) : null;
+
+        $body = (new StreamFactory())->createStreamFromFile('php://input', 'r', $cache);
+        $uploadedFiles = UploadedFile::createFromGlobals($_SERVER);
+
+        $request = new Request($method, $uri, $headers, $cookies, $_SERVER, $body, $uploadedFiles);
+        $contentTypes = $request->getHeader('Content-Type') ?? [];
+
+        $parsedContentType = '';
+        foreach ($contentTypes as $contentType) {
+            $fragments = explode(';', $contentType);
+            $parsedContentType = current($fragments);
+        }
+
+        $contentTypesWithParsedBodies = ['application/x-www-form-urlencoded', 'multipart/form-data'];
+        if ($method === 'POST' && in_array($parsedContentType, $contentTypesWithParsedBodies)) {
+            return $request->withParsedBody($_POST);
+        }
+
+        return $request;
+    }
+}

pma/vendor/slim/psr7/src/Factory/StreamFactory.php

@@ -0,0 +1,95 @@
+<?php
+
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @license https://github.com/slimphp/Slim-Psr7/blob/master/LICENSE.md (MIT License)
+ */
+
+declare(strict_types=1);
+
+namespace Slim\Psr7\Factory;
+
+use InvalidArgumentException;
+use Psr\Http\Message\StreamFactoryInterface;
+use Psr\Http\Message\StreamInterface;
+use RuntimeException;
+use Slim\Psr7\Stream;
+use ValueError;
+
+use function fopen;
+use function fwrite;
+use function is_resource;
+use function restore_error_handler;
+use function rewind;
+use function set_error_handler;
+
+class StreamFactory implements StreamFactoryInterface
+{
+    /**
+     * {@inheritdoc}
+     *
+     * @throws RuntimeException
+     */
+    public function createStream(string $content = ''): StreamInterface
+    {
+        $resource = fopen('php://temp', 'rw+');
+
+        if (!is_resource($resource)) {
+            throw new RuntimeException('StreamFactory::createStream() could not open temporary file stream.');
+        }
+
+        fwrite($resource, $content);
+        rewind($resource);
+
+        return $this->createStreamFromResource($resource);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createStreamFromFile(
+        string $filename,
+        string $mode = 'r',
+        StreamInterface $cache = null
+    ): StreamInterface {
+        set_error_handler(
+            static function (int $errno, string $errstr) use ($filename, $mode): void {
+                throw new RuntimeException(
+                    "Unable to open $filename using mode $mode: $errstr",
+                    $errno
+                );
+            }
+        );
+
+        try {
+            $resource = fopen($filename, $mode);
+        } catch (ValueError $exception) {
+            throw new RuntimeException("Unable to open $filename using mode $mode: " . $exception->getMessage());
+        } finally {
+            restore_error_handler();
+        }
+
+        if (!is_resource($resource)) {
+            throw new RuntimeException(
+                "StreamFactory::createStreamFromFile() could not create resource from file `$filename`"
+            );
+        }
+
+        return new Stream($resource, $cache);
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function createStreamFromResource($resource, StreamInterface $cache = null): StreamInterface
+    {
+        if (!is_resource($resource)) {
+            throw new InvalidArgumentException(
+                'Parameter 1 of StreamFactory::createStreamFromResource() must be a resource.'
+            );
+        }
+
+        return new Stream($resource, $cache);
+    }
+}

pma/vendor/slim/psr7/src/Factory/UploadedFileFactory.php

@@ -0,0 +1,47 @@
+<?php
+
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @license https://github.com/slimphp/Slim-Psr7/blob/master/LICENSE.md (MIT License)
+ */
+
+declare(strict_types=1);
+
+namespace Slim\Psr7\Factory;
+
+use InvalidArgumentException;
+use Psr\Http\Message\StreamInterface;
+use Psr\Http\Message\UploadedFileFactoryInterface;
+use Psr\Http\Message\UploadedFileInterface;
+use Slim\Psr7\UploadedFile;
+
+use function is_string;
+
+use const UPLOAD_ERR_OK;
+
+class UploadedFileFactory implements UploadedFileFactoryInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function createUploadedFile(
+        StreamInterface $stream,
+        ?int $size = null,
+        int $error = UPLOAD_ERR_OK,
+        ?string $clientFilename = null,
+        ?string $clientMediaType = null
+    ): UploadedFileInterface {
+        $file = $stream->getMetadata('uri');
+
+        if (!is_string($file) || !$stream->isReadable()) {
+            throw new InvalidArgumentException('File is not readable.');
+        }
+
+        if ($size === null) {
+            $size = $stream->getSize();
+        }
+
+        return new UploadedFile($stream, $clientFilename, $clientMediaType, $size, $error);
+    }
+}

pma/vendor/slim/psr7/src/Factory/UriFactory.php

@@ -0,0 +1,116 @@
+<?php
+
+/**
+ * Slim Framework (https://slimframework.com)
+ *
+ * @license https://github.com/slimphp/Slim-Psr7/blob/master/LICENSE.md (MIT License)
+ */
+
+declare(strict_types=1);
+
+namespace Slim\Psr7\Factory;
+
+use InvalidArgumentException;
+use Psr\Http\Message\UriFactoryInterface;
+use Psr\Http\Message\UriInterface;
+use Slim\Psr7\Uri;
+
+use function count;
+use function explode;
+use function parse_url;
+use function preg_match;
+use function strpos;
+use function strstr;
+use function substr;
+
+use const PHP_URL_QUERY;
+
+class UriFactory implements UriFactoryInterface
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function createUri(string $uri = ''): UriInterface
+    {
+        $parts = parse_url($uri);
+
+        if ($parts === false) {
+            throw new InvalidArgumentException('URI cannot be parsed');
+        }
+
+        $scheme = $parts['scheme'] ?? '';
+        $user = $parts['user'] ?? '';
+        $pass = $parts['pass'] ?? '';
+        $host = $parts['host'] ?? '';
+        $port = $parts['port'] ?? null;
+        $path = $parts['path'] ?? '';
+        $query = $parts['query'] ?? '';
+        $fragment = $parts['fragment'] ?? '';
+
+        return new Uri($scheme, $host, $port, $path, $query, $fragment, $user, $pass);
+    }
+
+    /**
+     * Create new Uri from environment.
+     *
+     * @internal This method is not part of PSR-17
+     *
+     * @param array $globals The global server variables.
+     *
+     * @return Uri
+     */
+    public function createFromGlobals(array $globals): Uri
+    {
+        // Scheme
+        $https = isset($globals['HTTPS']) ? $globals['HTTPS'] : false;
+        $scheme = !$https || $https === 'off' ? 'http' : 'https';
+
+        // Authority: Username and password
+        $username = isset($globals['PHP_AUTH_USER']) ? $globals['PHP_AUTH_USER'] : '';
+        $password = isset($globals['PHP_AUTH_PW']) ? $globals['PHP_AUTH_PW'] : '';
+
+        // Authority: Host
+        $host = '';
+        if (isset($globals['HTTP_HOST'])) {
+            $host = $globals['HTTP_HOST'];
+        } elseif (isset($globals['SERVER_NAME'])) {
+            $host = $globals['SERVER_NAME'];
+        }
+
+        // Authority: Port
+        $port = !empty($globals['SERVER_PORT']) ? (int)$globals['SERVER_PORT'] : ($scheme === 'https' ? 443 : 80);
+        if (preg_match('/^(\[[a-fA-F0-9:.]+])(:\d+)?\z/', $host, $matches)) {
+            $host = $matches[1];
+
+            if (isset($matches[2])) {
+                $port = (int) substr($matches[2], 1);
+            }
+        } else {
+            $pos = strpos($host, ':');
+            if ($pos !== false) {
+                $port = (int) substr($host, $pos + 1);
+                $host = strstr($host, ':', true);
+            }
+        }
+
+        // Query string
+        $queryString = '';
+        if (isset($globals['QUERY_STRING'])) {
+            $queryString = $globals['QUERY_STRING'];
+        }
+
+        // Request URI
+        $requestUri = '';
+        if (isset($globals['REQUEST_URI'])) {
+            $uriFragments = explode('?', $globals['REQUEST_URI']);
+            $requestUri = $uriFragments[0];
+
+            if ($queryString === '' && count($uriFragments) > 1) {
+                $queryString = parse_url('http://www.example.com' . $globals['REQUEST_URI'], PHP_URL_QUERY) ?? '';
+            }
+        }
+
+        // Build Uri and return
+        return new Uri($scheme, $host, $port, $requestUri, $queryString, '', $username, $password);
+    }
+}