Promise::then() - Code Metrics - Inspection of "CC-32047 Added support of guzzlehttp/guzzle librar..." - spryker-eco/akeneo-pim - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#23)

by Anton

created 2023-12-08 14:17 UTC

Promise::then() A

↳ Parent: Promise

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	1
c	1
b	0
f	0
nc	1
nop	2
dl	0
loc	3
rs	10

<?php

/**
 * Copyright © 2016-present Spryker Systems GmbH. All rights reserved.
 * Use of this software requires acceptance of the Evaluation License Agreement. See LICENSE file.
 */

namespace SprykerEco\Service\AkeneoPim\Dependencies\External\Api\Adapter\HttpClient;

use GuzzleHttp\Exception\ConnectException;
use GuzzleHttp\Exception\GuzzleException;
use GuzzleHttp\Exception\RequestException;
use GuzzleHttp\Promise\PromiseInterface;
use GuzzleHttp\Stream\Exception\SeekException;
filter:
    dependency_paths: ["lib/*"]
use Http\Client\Exception as HttpExceptionInterface;
use Http\Client\Exception\HttpException;
use Http\Client\Exception\NetworkException as HttpNetworkException;
use Http\Client\Exception\RequestException as HttpRequestException;
use Http\Client\Exception\TransferException as HttpTransferException;
use Http\Promise\Promise as HttpPromise;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use SprykerEco\Service\AkeneoPim\Dependencies\External\Api\Adapter\HttpClient\Exception\UnexpectedValueException;
use Throwable;

class Promise implements HttpPromise
{
    /**
     * @var \GuzzleHttp\Promise\PromiseInterface
     */
    protected $promise;

    /**
     * @var string
     */
    protected $state;

    /**
     * @var \Psr\Http\Message\ResponseInterface
     */
    protected $response;

    /**
     * @var \Http\Client\Exception
     */
    protected $exception;

    /**
     * @var \Psr\Http\Message\RequestInterface
     */
    protected $request;

    /**
     * @param \GuzzleHttp\Promise\PromiseInterface $promise
     * @param \Psr\Http\Message\RequestInterface $request
     */
    public function __construct(PromiseInterface $promise, RequestInterface $request)
    {
        $this->request = $request;
        $this->state = static::PENDING;
        $this->promise = $promise->then(function ($response) {
            return $this->handleResponse($response);
        }, function ($reason) use ($request) {
            $this->exception = $this->handleRejectCallback($reason, $request);

            throw $this->exception;
        });
    }

    /**
     * @param callable|null $onFulfilled
     * @param callable|null $onRejected
     *
     * @return \Http\Promise\Promise
     */
    public function then(?callable $onFulfilled = null, ?callable $onRejected = null): HttpPromise
    {
        return new static($this->promise->then($onFulfilled, $onRejected), $this->request);
    }

    /**
     * @return string
     */
    public function getState(): string
    {
        return $this->state;
    }

    /**
     * @param bool $unwrap
     *
     * @throws \Http\Client\Exception
     *
     * @return \Psr\Http\Message\ResponseInterface|null
     */
    public function wait($unwrap = true): ?ResponseInterface
    {
        $this->promise->wait(false);

        if (!$unwrap) {
            return null;
        }

        if ($this->getState() == static::REJECTED && $this->exception !== null) {
            throw $this->exception;
        }

        return $this->response;
    }

    /**
     * @param \Psr\Http\Message\ResponseInterface $response
     *
     * @return \Psr\Http\Message\ResponseInterface
     */
    protected function handleResponse(ResponseInterface $response): ResponseInterface
    {
        $this->response = $response;
        $this->state = static::FULFILLED;

        return $response;
    }

    /**
     * @param callable $rejectCallback
     * @param \Psr\Http\Message\RequestInterface $request
     *
     * @return \Http\Client\Exception
     */
    protected function handleRejectCallback(callable $rejectCallback, RequestInterface $request): HttpExceptionInterface
    {
        if ($rejectCallback instanceof HttpExceptionInterface) {
            return $rejectCallback;
        }

        if ($rejectCallback instanceof GuzzleException) {
            return $this->handleGuzzleException($rejectCallback, $request);
        }

        if ($rejectCallback instanceof Throwable) {
            return new HttpTransferException('Invalid exception returned from Guzzle', 0, $rejectCallback);
        }

        return new UnexpectedValueException('Reason returned from Guzzle must be an Exception');
    }

    /**
     * @param \GuzzleHttp\Exception\GuzzleException $exception
     * @param \Psr\Http\Message\RequestInterface $request
     *
     * @return \Http\Client\Exception
     */
    protected function handleGuzzleException(GuzzleException $exception, RequestInterface $request): HttpExceptionInterface
    {
        if ($exception instanceof SeekException) {
            return new HttpRequestException($exception->getMessage(), $request, $exception);
        }

        if ($exception instanceof ConnectException) {
            return new HttpNetworkException($exception->getMessage(), $exception->getRequest(), $exception);
        }

        if ($exception instanceof RequestException && $exception->hasResponse()) {
            return new HttpException(
                $exception->getMessage(),
                $exception->getRequest(),
                $exception->getResponse(),
                $exception
            );
        }

        if ($exception instanceof RequestException) {
            return new HttpRequestException($exception->getMessage(), $exception->getRequest(), $exception);
        }

        return new HttpTransferException($exception->getMessage(), 0, $exception);
    }
}


1			<?php
2
3			/**
4			* Copyright © 2016-present Spryker Systems GmbH. All rights reserved.
5			* Use of this software requires acceptance of the Evaluation License Agreement. See LICENSE file.
6			*/
7
8			namespace SprykerEco\Service\AkeneoPim\Dependencies\External\Api\Adapter\HttpClient;
9
10			use GuzzleHttp\Exception\ConnectException;
11			use GuzzleHttp\Exception\GuzzleException;
12			use GuzzleHttp\Exception\RequestException;
13			use GuzzleHttp\Promise\PromiseInterface;
14			use GuzzleHttp\Stream\Exception\SeekException;
			0 ignored issues – show Bug introduced 2023-12-07 16:08 UTC by Report Bug Copy Issue Report The type `GuzzleHttp\Stream\Exception\SeekException` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
15			use Http\Client\Exception as HttpExceptionInterface;
16			use Http\Client\Exception\HttpException;
17			use Http\Client\Exception\NetworkException as HttpNetworkException;
18			use Http\Client\Exception\RequestException as HttpRequestException;
19			use Http\Client\Exception\TransferException as HttpTransferException;
20			use Http\Promise\Promise as HttpPromise;
21			use Psr\Http\Message\RequestInterface;
22			use Psr\Http\Message\ResponseInterface;
23			use SprykerEco\Service\AkeneoPim\Dependencies\External\Api\Adapter\HttpClient\Exception\UnexpectedValueException;
24			use Throwable;
25
26			class Promise implements HttpPromise
27			{
28			/**
29			* @var \GuzzleHttp\Promise\PromiseInterface
30			*/
31			protected $promise;
32
33			/**
34			* @var string
35			*/
36			protected $state;
37
38			/**
39			* @var \Psr\Http\Message\ResponseInterface
40			*/
41			protected $response;
42
43			/**
44			* @var \Http\Client\Exception
45			*/
46			protected $exception;
47
48			/**
49			* @var \Psr\Http\Message\RequestInterface
50			*/
51			protected $request;
52
53			/**
54			* @param \GuzzleHttp\Promise\PromiseInterface $promise
55			* @param \Psr\Http\Message\RequestInterface $request
56			*/
57			public function __construct(PromiseInterface $promise, RequestInterface $request)
58			{
59			$this->request = $request;
60			$this->state = static::PENDING;
61			$this->promise = $promise->then(function ($response) {
62			return $this->handleResponse($response);
63			}, function ($reason) use ($request) {
64			$this->exception = $this->handleRejectCallback($reason, $request);
65
66			throw $this->exception;
67			});
68			}
69
70			/**
71			* @param callable\|null $onFulfilled
72			* @param callable\|null $onRejected
73			*
74			* @return \Http\Promise\Promise
75			*/
76			public function then(?callable $onFulfilled = null, ?callable $onRejected = null): HttpPromise
77			{
78			return new static($this->promise->then($onFulfilled, $onRejected), $this->request);
79			}
80
81			/**
82			* @return string
83			*/
84			public function getState(): string
85			{
86			return $this->state;
87			}
88
89			/**
90			* @param bool $unwrap
91			*
92			* @throws \Http\Client\Exception
93			*
94			* @return \Psr\Http\Message\ResponseInterface\|null
95			*/
96			public function wait($unwrap = true): ?ResponseInterface
97			{
98			$this->promise->wait(false);
99
100			if (!$unwrap) {
101			return null;
102			}
103
104			if ($this->getState() == static::REJECTED && $this->exception !== null) {
105			throw $this->exception;
106			}
107
108			return $this->response;
109			}
110
111			/**
112			* @param \Psr\Http\Message\ResponseInterface $response
113			*
114			* @return \Psr\Http\Message\ResponseInterface
115			*/
116			protected function handleResponse(ResponseInterface $response): ResponseInterface
117			{
118			$this->response = $response;
119			$this->state = static::FULFILLED;
120
121			return $response;
122			}
123
124			/**
125			* @param callable $rejectCallback
126			* @param \Psr\Http\Message\RequestInterface $request
127			*
128			* @return \Http\Client\Exception
129			*/
130			protected function handleRejectCallback(callable $rejectCallback, RequestInterface $request): HttpExceptionInterface
131			{
132			if ($rejectCallback instanceof HttpExceptionInterface) {
133			return $rejectCallback;
134			}
135
136			if ($rejectCallback instanceof GuzzleException) {
137			return $this->handleGuzzleException($rejectCallback, $request);
138			}
139
140			if ($rejectCallback instanceof Throwable) {
141			return new HttpTransferException('Invalid exception returned from Guzzle', 0, $rejectCallback);
142			}
143
144			return new UnexpectedValueException('Reason returned from Guzzle must be an Exception');
145			}
146
147			/**
148			* @param \GuzzleHttp\Exception\GuzzleException $exception
149			* @param \Psr\Http\Message\RequestInterface $request
150			*
151			* @return \Http\Client\Exception
152			*/
153			protected function handleGuzzleException(GuzzleException $exception, RequestInterface $request): HttpExceptionInterface
154			{
155			if ($exception instanceof SeekException) {
156			return new HttpRequestException($exception->getMessage(), $request, $exception);
157			}
158
159			if ($exception instanceof ConnectException) {
160			return new HttpNetworkException($exception->getMessage(), $exception->getRequest(), $exception);
161			}
162
163			if ($exception instanceof RequestException && $exception->hasResponse()) {
164			return new HttpException(
165			$exception->getMessage(),
166			$exception->getRequest(),
167			$exception->getResponse(),
168			$exception
169			);
170			}
171
172			if ($exception instanceof RequestException) {
173			return new HttpRequestException($exception->getMessage(), $exception->getRequest(), $exception);
174			}
175
176			return new HttpTransferException($exception->getMessage(), 0, $exception);
177			}
178			}
179

spryker-eco / akeneo-pim

Pull Request — master (#23)

Promise::then() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like