lockfile again

vendor/php-http/guzzle7-adapter/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2020 PHP HTTP Team <team@php-http.org>
+
+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.

vendor/php-http/guzzle7-adapter/composer.json

@@ -0,0 +1,43 @@
+{
+    "name": "php-http/guzzle7-adapter",
+    "description": "Guzzle 7 HTTP Adapter",
+    "license": "MIT",
+    "keywords": ["guzzle", "http"],
+    "homepage": "http://httplug.io",
+    "authors": [
+        {
+            "name": "Tobias Nyholm",
+            "email": "tobias.nyholm@gmail.com"
+        }
+    ],
+    "require": {
+        "php": "^7.3 | ^8.0",
+        "php-http/httplug": "^2.0",
+        "psr/http-client": "^1.0",
+        "guzzlehttp/guzzle": "^7.0"
+    },
+    "require-dev": {
+        "phpunit/phpunit": "^8.0|^9.3",
+        "php-http/client-integration-tests": "^3.0",
+        "phpspec/prophecy-phpunit": "^2.0",
+        "php-http/message-factory": "^1.1"
+    },
+    "provide": {
+        "php-http/client-implementation": "1.0",
+        "php-http/async-client-implementation": "1.0",
+        "psr/http-client-implementation": "1.0"
+    },
+    "autoload": {
+        "psr-4": {
+            "Http\\Adapter\\Guzzle7\\": "src/"
+        }
+    },
+    "autoload-dev": {
+        "psr-4": {
+            "Http\\Adapter\\Guzzle7\\Tests\\": "tests/"
+        }
+    },
+    "scripts": {
+        "test": "@php vendor/bin/phpunit"
+    }
+}

vendor/php-http/guzzle7-adapter/phpstan.neon.dist

@@ -0,0 +1,5 @@
+parameters:
+    level: 5
+    reportUnmatchedIgnoredErrors: false
+    paths:
+        - src

vendor/php-http/guzzle7-adapter/psalm.baseline.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<files psalm-version="3.14.2@3538fe1955d47f6ee926c0769d71af6db08aa488">
+  <file src="src/Promise.php">
+    <PossiblyNullArgument occurrences="1">
+      <code>$exception-&gt;getResponse()</code>
+    </PossiblyNullArgument>
+  </file>
+  <file src="src/Client.php">
+    <PossiblyUnusedMethod occurrences="1">
+      <code>createWithConfig</code>
+    </PossiblyUnusedMethod>
+  </file>
+</files>

vendor/php-http/guzzle7-adapter/psalm.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0"?>
+<psalm
+    errorLevel="3"
+    resolveFromConfigFile="true"
+    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns="https://getpsalm.org/schema/config"
+    xsi:schemaLocation="https://getpsalm.org/schema/config vendor/vimeo/psalm/config.xsd"
+    errorBaseline="psalm.baseline.xml"
+>
+    <projectFiles>
+        <directory name="src" />
+        <ignoreFiles>
+            <directory name="vendor" />
+        </ignoreFiles>
+    </projectFiles>
+</psalm>

vendor/php-http/guzzle7-adapter/src/Client.php

@@ -0,0 +1,69 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Http\Adapter\Guzzle7;
+
+use GuzzleHttp\Client as GuzzleClient;
+use GuzzleHttp\ClientInterface;
+use GuzzleHttp\HandlerStack;
+use GuzzleHttp\Middleware;
+use GuzzleHttp\Utils;
+use Http\Client\HttpAsyncClient;
+use Http\Client\HttpClient;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * HTTP Adapter for Guzzle 7.
+ *
+ * @author Tobias Nyholm <tobias.nyholm@gmail.com>
+ */
+final class Client implements HttpClient, HttpAsyncClient
+{
+    /**
+     * @var ClientInterface
+     */
+    private $guzzle;
+
+    public function __construct(?ClientInterface $guzzle = null)
+    {
+        if (!$guzzle) {
+            $guzzle = self::buildClient();
+        }
+
+        $this->guzzle = $guzzle;
+    }
+
+    /**
+     * Factory method to create the Guzzle 7 adapter with custom Guzzle configuration.
+     */
+    public static function createWithConfig(array $config): Client
+    {
+        return new self(self::buildClient($config));
+    }
+
+    public function sendRequest(RequestInterface $request): ResponseInterface
+    {
+        return $this->sendAsyncRequest($request)->wait();
+    }
+
+    public function sendAsyncRequest(RequestInterface $request)
+    {
+        $promise = $this->guzzle->sendAsync($request);
+
+        return new Promise($promise, $request);
+    }
+
+    /**
+     * Build the Guzzle client instance.
+     */
+    private static function buildClient(array $config = []): GuzzleClient
+    {
+        $handlerStack = new HandlerStack(Utils::chooseHandler());
+        $handlerStack->push(Middleware::prepareBody(), 'prepare_body');
+        $config = array_merge(['handler' => $handlerStack], $config);
+
+        return new GuzzleClient($config);
+    }
+}

vendor/php-http/guzzle7-adapter/src/Exception/UnexpectedValueException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Http\Adapter\Guzzle7\Exception;
+
+use Http\Client\Exception;
+
+final class UnexpectedValueException extends \UnexpectedValueException implements Exception
+{
+}

vendor/php-http/guzzle7-adapter/src/Promise.php

@@ -0,0 +1,123 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Http\Adapter\Guzzle7;
+
+use GuzzleHttp\Exception as GuzzleExceptions;
+use GuzzleHttp\Promise\PromiseInterface;
+use Http\Adapter\Guzzle7\Exception\UnexpectedValueException;
+use Http\Client\Exception as HttplugException;
+use Http\Promise\Promise as HttpPromise;
+use Psr\Http\Message\RequestInterface;
+use Psr\Http\Message\ResponseInterface;
+
+/**
+ * Wrapper around Guzzle promises.
+ *
+ * @author Joel Wurtz <joel.wurtz@gmail.com>
+ */
+final class Promise implements HttpPromise
+{
+    /**
+     * @var PromiseInterface
+     */
+    private $promise;
+
+    /**
+     * @var string State of the promise
+     */
+    private $state;
+
+    /**
+     * @var ResponseInterface
+     */
+    private $response;
+
+    /**
+     * @var HttplugException
+     */
+    private $exception;
+
+    /**
+     * @var RequestInterface
+     */
+    private $request;
+
+    public function __construct(PromiseInterface $promise, RequestInterface $request)
+    {
+        $this->request = $request;
+        $this->state = self::PENDING;
+        $this->promise = $promise->then(function ($response) {
+            $this->response = $response;
+            $this->state = self::FULFILLED;
+
+            return $response;
+        }, function ($reason) {
+            $this->state = self::REJECTED;
+
+            if ($reason instanceof HttplugException) {
+                $this->exception = $reason;
+            } elseif ($reason instanceof GuzzleExceptions\GuzzleException) {
+                $this->exception = $this->handleException($reason);
+            } elseif ($reason instanceof \Throwable) {
+                $this->exception = new HttplugException\TransferException('Invalid exception returned from Guzzle7', 0, $reason);
+            } else {
+                $this->exception = new UnexpectedValueException('Reason returned from Guzzle7 must be an Exception');
+            }
+
+            throw $this->exception;
+        });
+    }
+
+    public function then(?callable $onFulfilled = null, ?callable $onRejected = null)
+    {
+        return new static($this->promise->then($onFulfilled, $onRejected), $this->request);
+    }
+
+    public function getState()
+    {
+        return $this->state;
+    }
+
+    public function wait($unwrap = true)
+    {
+        $this->promise->wait(false);
+
+        if ($unwrap) {
+            if (self::REJECTED === $this->getState()) {
+                throw $this->exception;
+            }
+
+            return $this->response;
+        }
+    }
+
+    /**
+     * Converts a Guzzle exception into an Httplug exception.
+     *
+     * @return HttplugException
+     */
+    private function handleException(GuzzleExceptions\GuzzleException $exception)
+    {
+        if ($exception instanceof GuzzleExceptions\ConnectException) {
+            return new HttplugException\NetworkException($exception->getMessage(), $exception->getRequest(), $exception);
+        }
+
+        if ($exception instanceof GuzzleExceptions\RequestException) {
+            // Make sure we have a response for the HttpException
+            if ($exception->hasResponse()) {
+                return new HttplugException\HttpException(
+                    $exception->getMessage(),
+                    $exception->getRequest(),
+                    $exception->getResponse(),
+                    $exception
+                );
+            }
+
+            return new HttplugException\RequestException($exception->getMessage(), $exception->getRequest(), $exception);
+        }
+
+        return new HttplugException\TransferException($exception->getMessage(), 0, $exception);
+    }
+}