Client::createRequest() - Code Metrics - Inspection of "Added polyfill for `json_last_error_msg`." - gentlero/bitbucket-api - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( bb6001...f9dedd )

by Alexandru

created 2016-08-10 15:29 UTC

Client::createRequest() B

↳ Parent: Client

Complexity

Conditions	5
Paths	12

Size

Total Lines	22
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	5

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
c	1
b	0
f	0
dl	0
loc	22
ccs	15
cts	15
cp	1
rs	8.6737
cc	5
eloc	12
nc	12
nop	2
crap	5

<?php

/**
 * This file is part of the bitbucket-api package.
 *
 * (c) Alexandru G. <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace Bitbucket\API\Http;

use Buzz\Client\ClientInterface as BuzzClientInterface;
use Buzz\Client\Curl;
use Buzz\Message\MessageInterface;
use Buzz\Message\RequestInterface;
use Buzz\Message\Request;
use Buzz\Message\Response;
use Bitbucket\API\Http\Listener\ListenerInterface;

/**
 * @author  Alexandru G.    <[email protected]>
 */
class Client extends ClientListener implements ClientInterface
{
    /**
     * @var array
     */
    protected $options = array(
        'base_url'      => 'https://api.bitbucket.org',
        'api_version'   => '1.0',
        'api_versions'  => array('1.0', '2.0'),     // supported versions
        'format'        => 'json',
        'formats'       => array('json', 'xml'),    // supported response formats
        'user_agent'    => 'bitbucket-api-php/1.0.0-dev (https://bitbucket.org/gentlero/bitbucket-api)',
        'timeout'       => 10,
        'verify_peer'   => true
    );

    /**
     * @var BuzzClientInterface
     */
    protected $client;

    /**
     * @var RequestInterface
     */
    private $lastRequest;

    /**
     * @var MessageInterface
     */
    private $lastResponse;

    /**
     * @var MessageInterface
     */
    protected $responseObj;

    /**
     * @var RequestInterface
     */
    protected $requestObj;

    public function __construct(array $options = array(), BuzzClientInterface $client = null)
    {
        $this->client   = (null === $client) ? new Curl() : $client;
        $this->options  = array_merge($this->options, $options);

        $this->client->setTimeout($this->options['timeout']);
        $this->client->setVerifyPeer($this->options['verify_peer']);
    }

    /**
     * {@inheritdoc}
     */
    public function get($endpoint, $params = array(), $headers = array())
    {
        if (is_array($params) && count($params) > 0) {
            $endpoint   .= (strpos($endpoint, '?') === false ? '?' : '&').http_build_query($params, '', '&');
            $params     = array();
        }

        return $this->request($endpoint, $params, 'GET', $headers);
    }

    /**
     * {@inheritdoc}
     */
    public function post($endpoint, $params = array(), $headers = array())
    {
        return $this->request($endpoint, $params, 'POST', $headers);
    }

    /**
     * {@inheritdoc}
     */
    public function put($endpoint, $params = array(), $headers = array())
    {
        return $this->request($endpoint, $params, 'PUT', $headers);
    }

    /**
     * {@inheritdoc}
     */
    public function delete($endpoint, $params = array(), $headers = array())
    {
        return $this->request($endpoint, $params, 'DELETE', $headers);
    }

    /**
     * {@inheritdoc}
     */
    public function request($endpoint, $params = array(), $method = 'GET', array $headers = array())
    {
        $request = $this->createRequest($method, $endpoint);

        // add a default content-type if none was set
        if (empty($headers['Content-Type']) && in_array(strtoupper($method), array('POST', 'PUT'), true)) {
            $headers['Content-Type'] = 'application/x-www-form-urlencoded';
        }

        if (count($headers) > 0) {
            $request->addHeaders($headers);
        }

        if (count($params) > 0) {
            $request->setContent(is_array($params) ? http_build_query($params) : $params);
        }

        $response = is_object($this->responseObj) ? $this->responseObj : new Response();

        $this->executeListeners($request, 'preSend');

        $this->client->send($request, $response);

        $this->executeListeners($request, 'postSend', $response);

        $this->lastRequest  = $request;
        $this->lastResponse = $response;

        return $response;
    }

    /**
     * @access public
     * @return BuzzClientInterface
     */
    public function getClient()
    {
        return $this->client;
    }

    /**
     * {@inheritdoc}
     */
    public function getResponseFormat()
    {
        return $this->options['format'];
    }

    /**
     * {@inheritdoc}
     */
    public function setResponseFormat($format)
    {
        if (!in_array($format, $this->options['formats'], true)) {
            throw new \InvalidArgumentException(sprintf('Unsupported response format %s', $format));
        }

        $this->options['format'] = $format;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getApiVersion()
    {
        return $this->options['api_version'];
    }

    /**
     * {@inheritdoc}
     */
    public function setApiVersion($version)
    {
        if (!in_array($version, $this->options['api_versions'], true)) {
            throw new \InvalidArgumentException(sprintf('Unsupported API version %s', $version));
        }

        $this->options['api_version'] = $version;

        return $this;
    }

    /**
     * Check if specified API version is the one currently in use.
     *
     * @access public
     * @param  float $version
     * @return bool
     */
    public function isApiVersion($version)
    {
        return abs($this->options['api_version'] - $version) < 0.00001;
    }

    /**
     * {@inheritdoc}
     */
    public function getApiBaseUrl()
    {
        return $this->options['base_url'].'/'.$this->getApiVersion();
    }

    /**
     * @access public
     * @return MessageInterface
     */
    public function getLastRequest()
    {
        return $this->lastRequest;
    }

    /**
     * @access public
     * @return RequestInterface
     */
    public function getLastResponse()
    {
        return $this->lastResponse;
    }

    /**
     * @access public
     * @param  MessageInterface $response
     * @return void
     */
    public function setResponse(MessageInterface $response)
    {
        $this->responseObj = $response;
    }

    /**
     * @access public
     * @param  RequestInterface $request
     * @return void
     */
    public function setRequest(RequestInterface $request)
    {
        $this->requestObj = $request;
    }

    /**
     * @access protected
     * @param  string           $method
     * @param  string           $url
     * @return RequestInterface
     */
    protected function createRequest($method, $url)
    {
        // do not set base URL if a full one was provided
        if (false === strpos($url, $this->getApiBaseUrl())) {
            $url = $this->getApiBaseUrl().'/'.$url;
        }

        // change the response format
        if (strpos($url, 'format=') === false) {
            $url .= (strpos($url, '?') === false ? '?' : '&').'format='.$this->getResponseFormat();
        }

        $request = is_object($this->requestObj) ? $this->requestObj : new Request();
        $request->setMethod($method);
        $request->addHeaders(array(
                'User-Agent' => $this->options['user_agent']
            ));
        $request->setProtocolVersion(1.1);
        $request->fromUrl($url);

        return $request;
    }

    /**
     * Execute all available listeners.
     *
     * $when can be: preSend or postSend
     *
     * @access protected
     * @param RequestInterface $request
     * @param string           $when     When to execute the listener
     * @param MessageInterface $response
     */
    protected function executeListeners(RequestInterface $request, $when = 'preSend', MessageInterface $response = null)
    {
        $haveListeners  = count($this->listeners) > 0;

        if (!$haveListeners) {
            return;
        }

        $params = array($request);

        if (null !== $response) {
            $params[] = $response;
        }

        ksort($this->listeners, SORT_ASC);

        array_walk_recursive(
            $this->listeners,
            function ($class) use ($when, $params) {
                if ($class instanceof ListenerInterface) {
                    call_user_func_array(array($class, $when), $params);
                }
            }
        );
    }
}


1		<?php
2
3		/**
4		* This file is part of the bitbucket-api package.
5		*
6		* (c) Alexandru G. <[email protected]>
7		*
8		* For the full copyright and license information, please view the LICENSE
9		* file that was distributed with this source code.
10		*/
11		namespace Bitbucket\API\Http;
12
13		use Buzz\Client\ClientInterface as BuzzClientInterface;
14		use Buzz\Client\Curl;
15		use Buzz\Message\MessageInterface;
16		use Buzz\Message\RequestInterface;
17		use Buzz\Message\Request;
18		use Buzz\Message\Response;
19		use Bitbucket\API\Http\Listener\ListenerInterface;
20
21		/**
22		* @author Alexandru G. <[email protected]>
23		*/
24		class Client extends ClientListener implements ClientInterface
25		{
26		/**
27		* @var array
28		*/
29		protected $options = array(
30		'base_url' => 'https://api.bitbucket.org',
31		'api_version' => '1.0',
32		'api_versions' => array('1.0', '2.0'), // supported versions
33		'format' => 'json',
34		'formats' => array('json', 'xml'), // supported response formats
35		'user_agent' => 'bitbucket-api-php/1.0.0-dev (https://bitbucket.org/gentlero/bitbucket-api)',
36		'timeout' => 10,
37		'verify_peer' => true
38		);
39
40		/**
41		* @var BuzzClientInterface
42		*/
43		protected $client;
44
45		/**
46		* @var RequestInterface
47		*/
48		private $lastRequest;
49
50		/**
51		* @var MessageInterface
52		*/
53		private $lastResponse;
54
55		/**
56		* @var MessageInterface
57		*/
58		protected $responseObj;
59
60		/**
61		* @var RequestInterface
62		*/
63		protected $requestObj;
64
65	271	public function __construct(array $options = array(), BuzzClientInterface $client = null)
66		{
67	271	$this->client = (null === $client) ? new Curl() : $client;
68	271	$this->options = array_merge($this->options, $options);
69
70	271	$this->client->setTimeout($this->options['timeout']);
71	271	$this->client->setVerifyPeer($this->options['verify_peer']);
72	271	}
73
74		/**
75		* {@inheritdoc}
76		*/
77	5	public function get($endpoint, $params = array(), $headers = array())
78		{
79	5	if (is_array($params) && count($params) > 0) {
80	1	$endpoint .= (strpos($endpoint, '?') === false ? '?' : '&').http_build_query($params, '', '&');
81	1	$params = array();
82	1	}
83
84	5	return $this->request($endpoint, $params, 'GET', $headers);
85	1	}
86
87		/**
88		* {@inheritdoc}
89		*/
90	2	public function post($endpoint, $params = array(), $headers = array())
91		{
92	2	return $this->request($endpoint, $params, 'POST', $headers);
93		}
94
95		/**
96		* {@inheritdoc}
97		*/
98	1	public function put($endpoint, $params = array(), $headers = array())
99		{
100	1	return $this->request($endpoint, $params, 'PUT', $headers);
101		}
102
103		/**
104		* {@inheritdoc}
105		*/
106	2	public function delete($endpoint, $params = array(), $headers = array())
107		{
108	2	return $this->request($endpoint, $params, 'DELETE', $headers);
109		}
110
111		/**
112		* {@inheritdoc}
113		*/
114	10	public function request($endpoint, $params = array(), $method = 'GET', array $headers = array())
115		{
116	10	$request = $this->createRequest($method, $endpoint);
117
118		// add a default content-type if none was set
119	10	if (empty($headers['Content-Type']) && in_array(strtoupper($method), array('POST', 'PUT'), true)) {
120	3	$headers['Content-Type'] = 'application/x-www-form-urlencoded';
121	3	}
122
123	10	if (count($headers) > 0) {
124	8	$request->addHeaders($headers);
125	8	}
126
127	10	if (count($params) > 0) {
128	5	$request->setContent(is_array($params) ? http_build_query($params) : $params);
129	5	}
130
131	10	$response = is_object($this->responseObj) ? $this->responseObj : new Response();
132
133	10	$this->executeListeners($request, 'preSend');
134
135	9	$this->client->send($request, $response);
136
137	9	$this->executeListeners($request, 'postSend', $response);
138
139	9	$this->lastRequest = $request;
140	9	$this->lastResponse = $response;
141
142	9	return $response;
143		}
144
145		/**
146		* @access public
147		* @return BuzzClientInterface
148		*/
149	1	public function getClient()
150		{
151	1	return $this->client;
152		}
153
154		/**
155		* {@inheritdoc}
156		*/
157	12	public function getResponseFormat()
158		{
159	12	return $this->options['format'];
160		}
161
162		/**
163		* {@inheritdoc}
164		*/
165	4	public function setResponseFormat($format)
166		{
167	4	if (!in_array($format, $this->options['formats'], true)) {
168	2	throw new \InvalidArgumentException(sprintf('Unsupported response format %s', $format));
169		}
170
171	3	$this->options['format'] = $format;
172
173	3	return $this;
174		}
175
176		/**
177		* {@inheritdoc}
178		*/
179	12	public function getApiVersion()
180		{
181	12	return $this->options['api_version'];
182		}
183
184		/**
185		* {@inheritdoc}
186		*/
187	66	public function setApiVersion($version)
188		{
189	66	if (!in_array($version, $this->options['api_versions'], true)) {
190	1	throw new \InvalidArgumentException(sprintf('Unsupported API version %s', $version));
191		}
192
193	65	$this->options['api_version'] = $version;
194
195	65	return $this;
196		}
197
198		/**
199		* Check if specified API version is the one currently in use.
200		*
201		* @access public
202		* @param float $version
203		* @return bool
204		*/
205	1	public function isApiVersion($version)
206		{
207	1	return abs($this->options['api_version'] - $version) < 0.00001;
208		}
209
210		/**
211		* {@inheritdoc}
212		*/
213	11	public function getApiBaseUrl()
214		{
215	11	return $this->options['base_url'].'/'.$this->getApiVersion();
216		}
217
218		/**
219		* @access public
220		* @return MessageInterface
221		*/
222	5	public function getLastRequest()
223		{
224	5	return $this->lastRequest;
225		}
226
227		/**
228		* @access public
229		* @return RequestInterface
230		*/
231	2	public function getLastResponse()
232		{
233	2	return $this->lastResponse;
234		}
235
236		/**
237		* @access public
238		* @param MessageInterface $response
239		* @return void
240		*/
241		public function setResponse(MessageInterface $response)
242		{
243		$this->responseObj = $response;
244		}
245
246		/**
247		* @access public
248		* @param RequestInterface $request
249		* @return void
250		*/
251		public function setRequest(RequestInterface $request)
252		{
253		$this->requestObj = $request;
254		}
255
256		/**
257		* @access protected
258		* @param string $method
259		* @param string $url
260		* @return RequestInterface
261		*/
262	10	protected function createRequest($method, $url)
263		{
264		// do not set base URL if a full one was provided
265	10	if (false === strpos($url, $this->getApiBaseUrl())) {
266	9	$url = $this->getApiBaseUrl().'/'.$url;
267	9	}
268
269		// change the response format
270	10	if (strpos($url, 'format=') === false) {
271	9	$url .= (strpos($url, '?') === false ? '?' : '&').'format='.$this->getResponseFormat();
272	9	}
273
274	10	$request = is_object($this->requestObj) ? $this->requestObj : new Request();
275	10	$request->setMethod($method);
276	10	$request->addHeaders(array(
277	10	'User-Agent' => $this->options['user_agent']
278	10	));
279	10	$request->setProtocolVersion(1.1);
280	10	$request->fromUrl($url);
281
282	10	return $request;
283		}
284
285		/**
286		* Execute all available listeners.
287		*
288		* $when can be: preSend or postSend
289		*
290		* @access protected
291		* @param RequestInterface $request
292		* @param string $when When to execute the listener
293		* @param MessageInterface $response
294		*/
295	10	protected function executeListeners(RequestInterface $request, $when = 'preSend', MessageInterface $response = null)
296		{
297	10	$haveListeners = count($this->listeners) > 0;
298
299	10	if (!$haveListeners) {
300	6	return;
301		}
302
303	5	$params = array($request);
304
305	5	if (null !== $response) {
306	3	$params[] = $response;
307	3	}
308
309	5	ksort($this->listeners, SORT_ASC);
310
311	5	array_walk_recursive(
312	5	$this->listeners,
313		function ($class) use ($when, $params) {
314	5	if ($class instanceof ListenerInterface) {
315	5	call_user_func_array(array($class, $when), $params);
316	5	}
317	5	}
318	5	);
319	3	}
320		}
321

gentlero / bitbucket-api

Notification Setup Error

Push — develop ( bb6001...f9dedd )

Client::createRequest() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like