Client::getBuzzHeaders() - Code Metrics - Inspection of "Updated changelog." - php-http/buzz-adapter - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 849302...2b5725 )

by Tobias

created 2017-07-07 22:43 UTC

Client::getBuzzHeaders() A

↳ Parent: Client

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	9
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	12
ccs	9
cts	9
cp	1
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	8
nc	2
nop	1
crap	2

<?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\RequestInterface as BuzzRequestInterface;
use Buzz\Message\Response as BuzzResponse;
use Http\Client\HttpClient;
use Http\Discovery\MessageFactoryDiscovery;
use Http\Message\ResponseFactory;
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
{
    /**
     * @var ClientInterface
     */
    private $client;

    /**
     * @var ResponseFactory
     */
    private $responseFactory;

    /**
     * @param ClientInterface|Browser|null $client
     * @param ResponseFactory|null         $responseFactory
     */
    public function __construct($client = null, ResponseFactory $responseFactory = 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->responseFactory = $responseFactory ?: 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\RequestException $e) {
            throw new HttplugException\RequestException($e->getMessage(), $request, $e);
        } 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->responseFactory->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)
    {
        $validMethods = [
            BuzzRequestInterface::METHOD_POST,
            BuzzRequestInterface::METHOD_PUT,
            BuzzRequestInterface::METHOD_DELETE,
            BuzzRequestInterface::METHOD_PATCH,
            BuzzRequestInterface::METHOD_OPTIONS,
        ];

        // 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()->getSize() &&
0   == false // true
0   == null  // true
123 == false // false
123 == null  // false

// It is often better to use strict comparison
0 === false // false
0 === null  // false
            !in_array(strtoupper($request->getMethod()), $validMethods, true)
        ) {
            throw new HttplugException\RequestException(
                sprintf('%s does not support %s requests with a body', Curl::class, $request->getMethod()),
                $request
            );
        }
    }
}


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\RequestInterface as BuzzRequestInterface;
12		use Buzz\Message\Response as BuzzResponse;
13		use Http\Client\HttpClient;
14		use Http\Discovery\MessageFactoryDiscovery;
15		use Http\Message\ResponseFactory;
16		use Psr\Http\Message\RequestInterface;
17		use Psr\Http\Message\ResponseInterface;
18		use Http\Client\Exception as HttplugException;
19
20		/**
21		* @author Tobias Nyholm <[email protected]>
22		*/
23		class Client implements HttpClient
24		{
25		/**
26		* @var ClientInterface
27		*/
28		private $client;
29
30		/**
31		* @var ResponseFactory
32		*/
33		private $responseFactory;
34
35		/**
36		* @param ClientInterface\|Browser\|null $client
37		* @param ResponseFactory\|null $responseFactory
38		*/
39	214	public function __construct($client = null, ResponseFactory $responseFactory = null)
40		{
41	214	$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...
42
43	214	if ($this->client === null) {
44	53	$this->client = new FileGetContents();
45	54	$this->client->setMaxRedirects(0);
46	53	}
47
48	214	if ((!$this->client instanceof ClientInterface) && (!$this->client instanceof Browser)) {
49	2	throw new \InvalidArgumentException(
50	2	sprintf(
51	2	'The client passed to the Buzz adapter must either implement %s or be an instance of %s. You passed %s.',
52	2	ClientInterface::class,
53	2	Browser::class,
54	2	is_object($client) ? get_class($client) : gettype($client)
55	2	)
56	2	);
57		}
58
59	212	$this->responseFactory = $responseFactory ?: MessageFactoryDiscovery::find();
60	212	}
61
62		/**
63		* {@inheritdoc}
64		*/
65	212	public function sendRequest(RequestInterface $request)
66		{
67	212	$this->assertRequestHasValidBody($request);
68
69	200	$buzzRequest = $this->createRequest($request);
70
71		try {
72	200	$buzzResponse = new BuzzResponse();
73	200	$this->client->send($buzzRequest, $buzzResponse);
74	200	} catch (BuzzException\RequestException $e) {
75	4	throw new HttplugException\RequestException($e->getMessage(), $request, $e);
76		} catch (BuzzException\ClientException $e) {
77		throw new HttplugException\TransferException($e->getMessage(), 0, $e);
78		}
79
80	196	return $this->createResponse($buzzResponse);
81		}
82
83		/**
84		* Converts a PSR request into a BuzzRequest request.
85		*
86		* @param RequestInterface $request
87		*
88		* @return BuzzRequest
89		*/
90	200	private function createRequest(RequestInterface $request)
91		{
92	200	$buzzRequest = new BuzzRequest();
93	200	$buzzRequest->setMethod($request->getMethod());
94	200	$buzzRequest->fromUrl($request->getUri()->__toString());
95	200	$buzzRequest->setProtocolVersion($request->getProtocolVersion());
96	200	$buzzRequest->setContent((string) $request->getBody());
97
98	200	$this->addPsrHeadersToBuzzRequest($request, $buzzRequest);
99
100	200	return $buzzRequest;
101		}
102
103		/**
104		* Converts a Buzz response into a PSR response.
105		*
106		* @param BuzzResponse $response
107		*
108		* @return ResponseInterface
109		*/
110	196	private function createResponse(BuzzResponse $response)
111		{
112	196	$body = $response->getContent();
113
114	196	return $this->responseFactory->createResponse(
115	196	$response->getStatusCode(),
116	196	null,
117	196	$this->getBuzzHeaders($response),
118	196	$body,
119	196	number_format($response->getProtocolVersion(), 1)
120	196	);
121		}
122
123		/**
124		* Apply headers on a Buzz request.
125		*
126		* @param RequestInterface $request
127		* @param BuzzRequest $buzzRequest
128		*/
129	200	private function addPsrHeadersToBuzzRequest(RequestInterface $request, BuzzRequest $buzzRequest)
130		{
131	200	$headers = $request->getHeaders();
132	200	foreach ($headers as $name => $values) {
133	200	foreach ($values as $header) {
134	200	$buzzRequest->addHeader($name.': '.$header);
135	200	}
136	200	}
137	200	}
138
139		/**
140		* Get headers from a Buzz response.
141		*
142		* @param BuzzResponse $response
143		*
144		* @return array
145		*/
146	196	private function getBuzzHeaders(BuzzResponse $response)
147		{
148	196	$buzzHeaders = $response->getHeaders();
149	196	unset($buzzHeaders[0]);
150	196	$headers = [];
151	196	foreach ($buzzHeaders as $headerLine) {
152	196	list($name, $value) = explode(':', $headerLine, 2);
153	196	$headers[$name] = trim($value);
154	196	}
155
156	196	return $headers;
157		}
158
159		/**
160		* Assert that the request has a valid body based on the request method.
161		*
162		* @param RequestInterface $request
163		*/
164	212	private function assertRequestHasValidBody(RequestInterface $request)
165		{
166		$validMethods = [
167	212	BuzzRequestInterface::METHOD_POST,
168	212	BuzzRequestInterface::METHOD_PUT,
169	212	BuzzRequestInterface::METHOD_DELETE,
170	212	BuzzRequestInterface::METHOD_PATCH,
171	212	BuzzRequestInterface::METHOD_OPTIONS,
172	212	];
173
174		// The Buzz Curl client does not send request bodies for request methods such as GET, HEAD and TRACE. Instead of
175		// silently ignoring the request body in these cases, throw an exception to make users aware.
176	212	if ($this->client instanceof Curl &&
177	212	$request->getBody()->getSize() &&
		0 ignored issues – show Bug Best Practice introduced 2016-07-07 19:49 UTC by Report Bug Copy Issue Report The expression `$request->getBody()->getSize()` of type `integer\|null` is loosely compared to `true`; this is ambiguous if the integer can be zero. You might want to explicitly use `!== null` instead. In PHP, under loose comparison (like `==`, or `!=`, or `switch` conditions), values of different types might be equal. For `integer` values, zero is a special case, in particular the following results might be unexpected: 0 == false // true 0 == null // true 123 == false // false 123 == null // false // It is often better to use strict comparison 0 === false // false 0 === null // false Loading history...
178	20	!in_array(strtoupper($request->getMethod()), $validMethods, true)
179	212	) {
180	12	throw new HttplugException\RequestException(
181	12	sprintf('%s does not support %s requests with a body', Curl::class, $request->getMethod()),
182		$request
183	12	);
184		}
185	200	}
186		}
187

php-http / buzz-adapter

Push — master ( 849302...2b5725 )

Client::getBuzzHeaders() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like