Client::addPsrHeadersToBuzzRequest() - Code Metrics - Inspection of "Add support for using Buzz\Browser instance (fixes..." - php-http/buzz-adapter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#4)

unknown

created 2016-07-07 14:14 UTC

Client::addPsrHeadersToBuzzRequest() A

↳ Parent: Client

Complexity

Conditions	3
Paths	3

Size

Total Lines	9
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	3

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	9
ccs	3
cts	3
cp	1
rs	9.6666
cc	3
eloc	5
nc	3
nop	2
crap	3

<?php

namespace Http\Adapter\Buzz;

use Buzz\Browser;
use Buzz\Client\ClientInterface;
use Buzz\Client\Curl;
use Buzz\Client\FileGetContents;
use Buzz\Exception as BuzzException;
use Buzz\Message\Request as BuzzRequest;
use Buzz\Message\Response as BuzzResponse;
use Http\Client\HttpClient;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Message\MessageFactory;
use Psr\Http\Message\RequestInterface;
use Psr\Http\Message\ResponseInterface;
use Http\Client\Exception as HttplugException;

/**
 * @author Tobias Nyholm <[email protected]>
 */
class Client implements HttpClient
{
    /**
     * Request methods which can have bodies (according to Buzz's Curl client).
     */
    const VALID_METHODS_WITH_BODIES = ['POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'];

    /**
     * @var ClientInterface
     */
    private $client;

    /**
     * @var MessageFactory
     */
    private $messageFactory;

    /**
     * @param ClientInterface|Browser|null $client
     * @param MessageFactory|null          $messageFactory
     */
    public function __construct($client = null, MessageFactory $messageFactory = null)
    {
        $this->client = $client;
class Id
{
    public $id;

    public function __construct($id)
    {
        $this->id = $id;
    }

}

class Account
{
    /** @var  Id $id */
    public $id;
}

$account_id = false;

if (starsAreRight()) {
    $account_id = new Id(42);
}

$account = new Account();
if ($account instanceof Id)
{
    $account->id = $account_id;
}

        if ($this->client === null) {
            $this->client = new FileGetContents();
            $this->client->setMaxRedirects(0);
        }

        if ((!$this->client instanceof ClientInterface) && (!$this->client instanceof Browser)) {
            throw new \InvalidArgumentException(
                sprintf(
                    'The client passed to the Buzz adapter must either implement %s or be an instance of %s. You passed %s.',
                    ClientInterface::class,
                    Browser::class,
                    is_object($client) ? get_class($client) : gettype($client)
                )
            );
        }

        $this->messageFactory = $messageFactory ?: MessageFactoryDiscovery::find();
    }

    /**
     * {@inheritdoc}
     */
    public function sendRequest(RequestInterface $request)
    {
        $this->assertRequestHasValidBody($request);

        $buzzRequest = $this->createRequest($request);

        try {
            $buzzResponse = new BuzzResponse();
            $this->client->send($buzzRequest, $buzzResponse);
        } catch (BuzzException\ClientException $e) {
            throw new HttplugException\TransferException($e->getMessage(), 0, $e);
        }

        return $this->createResponse($buzzResponse);
    }

    /**
     * Converts a PSR request into a BuzzRequest request.
     *
     * @param RequestInterface $request
     *
     * @return BuzzRequest
     */
    private function createRequest(RequestInterface $request)
    {
        $buzzRequest = new BuzzRequest();
        $buzzRequest->setMethod($request->getMethod());
        $buzzRequest->fromUrl($request->getUri()->__toString());
        $buzzRequest->setProtocolVersion($request->getProtocolVersion());
        $buzzRequest->setContent((string) $request->getBody());

        $this->addPsrHeadersToBuzzRequest($request, $buzzRequest);

        return $buzzRequest;
    }

    /**
     * Converts a Buzz response into a PSR response.
     *
     * @param BuzzResponse $response
     *
     * @return ResponseInterface
     */
    private function createResponse(BuzzResponse $response)
    {
        $body = $response->getContent();

        return $this->messageFactory->createResponse(
            $response->getStatusCode(),
            null,
            $this->getBuzzHeaders($response),
            $body,
            number_format($response->getProtocolVersion(), 1)
        );
    }

    /**
     * Apply headers on a Buzz request.
     *
     * @param RequestInterface $request
     * @param BuzzRequest      $buzzRequest
     */
    private function addPsrHeadersToBuzzRequest(RequestInterface $request, BuzzRequest $buzzRequest)
    {
        $headers = $request->getHeaders();
        foreach ($headers as $name => $values) {
            foreach ($values as $header) {
                $buzzRequest->addHeader($name.': '.$header);
            }
        }
    }

    /**
     * Get headers from a Buzz response.
     *
     * @param BuzzResponse $response
     *
     * @return array
     */
    private function getBuzzHeaders(BuzzResponse $response)
    {
        $buzzHeaders = $response->getHeaders();
        unset($buzzHeaders[0]);
        $headers = [];
        foreach ($buzzHeaders as $headerLine) {
            list($name, $value) = explode(':', $headerLine, 2);
            $headers[$name] = trim($value);
        }

        return $headers;
    }

    /**
     * Assert that the request has a valid body based on the request method.
     *
     * @param RequestInterface $request
     */
    private function assertRequestHasValidBody(RequestInterface $request)
    {
        // The Buzz Curl client does not send request bodies for request methods such as GET, HEAD and TRACE. Instead of
        // silently ignoring the request body in these cases, throw an exception to make users aware.
        if ($this->client instanceof Curl &&
            $request->getBody()->getContents() &&
            !in_array(strtoupper($request->getMethod()), static::VALID_METHODS_WITH_BODIES, true)
        ) {
            throw new \InvalidArgumentException(
                sprintf('%s does not support %s requests with a body', Curl::class, $request->getMethod())
            );
        }
    }
}


1		<?php
2
3		namespace Http\Adapter\Buzz;
4
5		use Buzz\Browser;
6		use Buzz\Client\ClientInterface;
7		use Buzz\Client\Curl;
8		use Buzz\Client\FileGetContents;
9		use Buzz\Exception as BuzzException;
10		use Buzz\Message\Request as BuzzRequest;
11		use Buzz\Message\Response as BuzzResponse;
12		use Http\Client\HttpClient;
13		use Http\Discovery\MessageFactoryDiscovery;
14		use Http\Message\MessageFactory;
15		use Psr\Http\Message\RequestInterface;
16		use Psr\Http\Message\ResponseInterface;
17		use Http\Client\Exception as HttplugException;
18
19		/**
20		* @author Tobias Nyholm <[email protected]>
21		*/
22		class Client implements HttpClient
23		{
24		/**
25		* Request methods which can have bodies (according to Buzz's Curl client).
26		*/
27		const VALID_METHODS_WITH_BODIES = ['POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'];
28
29		/**
30		* @var ClientInterface
31		*/
32		private $client;
33
34		/**
35		* @var MessageFactory
36	53	*/
37		private $messageFactory;
38	53
39	53	/**
40		* @param ClientInterface\|Browser\|null $client
41	53	* @param MessageFactory\|null $messageFactory
42	53	*/
43		public function __construct($client = null, MessageFactory $messageFactory = null)
44		{
45		$this->client = $client;
		0 ignored issues – show Documentation Bug introduced 2016-07-06 09:36 UTC by Report Bug Copy Issue Report It seems like `$client` can also be of type `object<Buzz\Browser>`. However, the property `$client` is declared as type `object<Buzz\Client\ClientInterface>`. Maybe add an additional type check? Our type inference engine has found a suspicous assignment of a value to a property. This check raises an issue when a value that can be of a mixed type is assigned to a property that is type hinted more strictly. For example, imagine you have a variable `$accountId` that can either hold an Id object or false (if there is no account id yet). Your code now assigns that value to the `id` property of an instance of the `Account` class. This class holds a proper account, so the id value must no longer be false. Either this assignment is in error or a type check should be added for that assignment. class Id { public $id; public function __construct($id) { $this->id = $id; } } class Account { /** @var Id $id */ public $id; } $account_id = false; if (starsAreRight()) { $account_id = new Id(42); } $account = new Account(); if ($account instanceof Id) { $account->id = $account_id; } Loading history...
46
47	53	if ($this->client === null) {
48		$this->client = new FileGetContents();
49	53	$this->client->setMaxRedirects(0);
50		}
51
52	53	if ((!$this->client instanceof ClientInterface) && (!$this->client instanceof Browser)) {
53	53	throw new \InvalidArgumentException(
54	53	sprintf(
55	1	'The client passed to the Buzz adapter must either implement %s or be an instance of %s. You passed %s.',
56		ClientInterface::class,
57		Browser::class,
58	52	is_object($client) ? get_class($client) : gettype($client)
59		)
60		);
61		}
62
63		$this->messageFactory = $messageFactory ?: MessageFactoryDiscovery::find();
64		}
65
66		/**
67		* {@inheritdoc}
68	53	*/
69		public function sendRequest(RequestInterface $request)
70	53	{
71	53	$this->assertRequestHasValidBody($request);
72	53
73	53	$buzzRequest = $this->createRequest($request);
74	53
75		try {
76	53	$buzzResponse = new BuzzResponse();
77		$this->client->send($buzzRequest, $buzzResponse);
78	53	} catch (BuzzException\ClientException $e) {
79		throw new HttplugException\TransferException($e->getMessage(), 0, $e);
80		}
81
82		return $this->createResponse($buzzResponse);
83		}
84
85		/**
86		* Converts a PSR request into a BuzzRequest request.
87		*
88	52	* @param RequestInterface $request
89		*
90	52	* @return BuzzRequest
91		*/
92	52	private function createRequest(RequestInterface $request)
93	52	{
94	52	$buzzRequest = new BuzzRequest();
95	52	$buzzRequest->setMethod($request->getMethod());
96	52	$buzzRequest->fromUrl($request->getUri()->__toString());
97	52	$buzzRequest->setProtocolVersion($request->getProtocolVersion());
98	52	$buzzRequest->setContent((string) $request->getBody());
99
100		$this->addPsrHeadersToBuzzRequest($request, $buzzRequest);
101
102		return $buzzRequest;
103		}
104
105		/**
106		* Converts a Buzz response into a PSR response.
107	53	*
108	1	* @param BuzzResponse $response
109	53	*
110	53	* @return ResponseInterface
111	53	*/
112	53	private function createResponse(BuzzResponse $response)
113	53	{
114	53	$body = $response->getContent();
115	53
116		return $this->messageFactory->createResponse(
117		$response->getStatusCode(),
118		null,
119		$this->getBuzzHeaders($response),
120		$body,
121		number_format($response->getProtocolVersion(), 1)
122		);
123		}
124	52
125		/**
126	52	* Apply headers on a Buzz request.
127	52	*
128	52	* @param RequestInterface $request
129	52	* @param BuzzRequest $buzzRequest
130	52	*/
131	52	private function addPsrHeadersToBuzzRequest(RequestInterface $request, BuzzRequest $buzzRequest)
132	52	{
133		$headers = $request->getHeaders();
134	52	foreach ($headers as $name => $values) {
135		foreach ($values as $header) {
136		$buzzRequest->addHeader($name.': '.$header);
137		}
138		}
139		}
140
141		/**
142		* Get headers from a Buzz response.
143		*
144		* @param BuzzResponse $response
145		*
146		* @return array
147		*/
148		private function getBuzzHeaders(BuzzResponse $response)
149		{
150		$buzzHeaders = $response->getHeaders();
151		unset($buzzHeaders[0]);
152		$headers = [];
153		foreach ($buzzHeaders as $headerLine) {
154		list($name, $value) = explode(':', $headerLine, 2);
155		$headers[$name] = trim($value);
156		}
157
158		return $headers;
159		}
160
161		/**
162		* Assert that the request has a valid body based on the request method.
163		*
164		* @param RequestInterface $request
165		*/
166		private function assertRequestHasValidBody(RequestInterface $request)
167		{
168		// The Buzz Curl client does not send request bodies for request methods such as GET, HEAD and TRACE. Instead of
169		// silently ignoring the request body in these cases, throw an exception to make users aware.
170		if ($this->client instanceof Curl &&
171		$request->getBody()->getContents() &&
172		!in_array(strtoupper($request->getMethod()), static::VALID_METHODS_WITH_BODIES, true)
173		) {
174		throw new \InvalidArgumentException(
175		sprintf('%s does not support %s requests with a body', Curl::class, $request->getMethod())
176		);
177		}
178		}
179		}
180

php-http / buzz-adapter

Pull Request — master (#4)

Client::addPsrHeadersToBuzzRequest() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like