Graze\GuzzleHttp\JsonRpc\Client

Complexity

Total Complexity

13

Size/Duplication

Total Lines	165
Duplicated Lines	10.3 %

Coupling/Cohesion

Components	1
Dependencies	8

Test Coverage

Coverage

98.21%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	factory()	0	16	2
A	notification()	8	8	1
A	request()	9	9	1
A	send()	0	6	2
A	sendAll()	0	9	1
A	createMessageFactory()	0	4	1
A	createRequest()	0	6	1
A	getMessageFactory()	0	9	1
A	getBatchRequestOptions()	0	6	1
A	getBatchResponses()	0	13	1

<?php
/*
 * This file is part of Guzzle HTTP JSON-RPC
 *
 * Copyright (c) 2014 Nature Delivered Ltd. <http://graze.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @see  http://github.com/graze/guzzle-jsonrpc/blob/master/LICENSE
 * @link http://github.com/graze/guzzle-jsonrpc
 */
namespace Graze\GuzzleHttp\JsonRpc;

use Closure;
use Graze\GuzzleHttp\JsonRpc\Message\MessageFactory;
use Graze\GuzzleHttp\JsonRpc\Message\RequestInterface;
use Graze\GuzzleHttp\JsonRpc\Message\ResponseInterface;
use GuzzleHttp\Client as HttpClient;
use GuzzleHttp\ClientInterface as HttpClientInterface;
use GuzzleHttp\Message\MessageFactoryInterface;
use GuzzleHttp\Utils as GuzzleUtils;

class Client implements ClientInterface
{
    /**
     * @var HttpClientInterface
     */
    protected $httpClient;

    /**
     * @param HttpClientInterface $httpClient
     */
    public function __construct(HttpClientInterface $httpClient)
    {
        $this->httpClient = $httpClient;
    }

    /**
     * @param  string $url
     * @param  array  $config
     * @return Client
     */
    public static function factory($url, array $config = [])
    {
        $client = new HttpClient(array_replace_recursive([
            'base_url' => $url,
            'message_factory' => self::createMessageFactory(),
            'defaults' => [
                'headers' => [
                    'Accept-Encoding' => 'gzip;q=1.0,deflate;q=0.6,identity;q=0.3'
                ]
            ]
        ], $config));
        if (isset($config['subscribers'])) {
            array_map([$client->getEmitter(), 'attach'], $config['subscribers']);
        }
        return new self($client);
    }

    /**
     * {@inheritdoc}
     *
     * @link   http://www.jsonrpc.org/specification#notification
     * @param  string           $method
     * @param  array            $params

Should the type for parameter $params not be null|array?

     * @return RequestInterface
     */
    public function notification($method, array $params = null)

This method seems to be duplicated in your project.

    {
        return $this->createRequest(RequestInterface::NOTIFICATION, array_filter([
            'jsonrpc' => static::SPEC,
            'method'  => $method,
            'params'  => $params
        ]));
    }

    /**
     * {@inheritdoc}
     *
     * @link   http://www.jsonrpc.org/specification#request_object
     * @param  mixed            $id
     * @param  string           $method
     * @param  array            $params

Should the type for parameter $params not be null|array?

     * @return RequestInterface
     */
    public function request($id, $method, array $params = null)

This method seems to be duplicated in your project.

    {
        return $this->createRequest(RequestInterface::REQUEST, array_filter([
            'jsonrpc' => static::SPEC,
            'method'  => $method,
            'params'  => $params,
            'id'      => $id
        ]));
    }

    /**
     * {@inheritdoc}
     *
     * @param  RequestInterface       $request
     * @return ResponseInterface|null

Should the return type not be \GuzzleHttp\Message\ResponseInterface|null?

     */
    public function send(RequestInterface $request)
    {
        $response = $this->httpClient->send($request);

        return $request->getRpcId() ? $response : null;
    }

    /**
     * {@inheritdoc}
     *
     * @link   http://www.jsonrpc.org/specification#batch
     * @param  RequestInterface[]  $requests
     * @return ResponseInterface[]
     */
    public function sendAll(array $requests)
    {
        $response = $this->httpClient->send($this->createRequest(
            RequestInterface::BATCH,
            $this->getBatchRequestOptions($requests)
        ));

        return $this->getBatchResponses($response);

$response of type object<GuzzleHttp\Message\ResponseInterface> is not a sub-type of object<Graze\GuzzleHttp\JsonRpc\Message\ResponseInterface>. It seems like you assume a child interface of the interface GuzzleHttp\Message\ResponseInterface to be always present.

    }

    /**
     * @return MessageFactoryInterface
     */
    protected static function createMessageFactory()
    {
        return new MessageFactory();
    }

    /**
     * @param  string           $method
     * @param  array            $options
     * @return RequestInterface
     */
    protected function createRequest($method, array $options)
    {
        return $this->httpClient->createRequest($method, null, [
            'jsonrpc' => $options
        ]);
    }

    /**
     * @return MessageFactoryInterface
     */
    protected function getMessageFactory()
    {
        // This is pretty lame, but we need the factory from the client
        $factoryExtractor = Closure::bind(function () {
            return $this->messageFactory;

The property messageFactory does not exist. Did you maybe forget to declare it?

        }, $this->httpClient, $this->httpClient);

        return $factoryExtractor();
    }

    /**
     * @param  RequestInterface[] $requests
     * @return array
     */
    protected function getBatchRequestOptions(array $requests)
    {
        return array_map(function (RequestInterface $request) {
            return GuzzleUtils::jsonDecode((string) $request->getBody());
        }, $requests);
    }

    /**
     * @param  ResponseInterface  $response
     * @return ResponseInterface[]
     */
    protected function getBatchResponses(ResponseInterface $response)
    {
        $factory = $this->getMessageFactory();
        $results = GuzzleUtils::jsonDecode((string) $response->getBody(), true);

        return array_map(function (array $result) use ($factory, $response) {
            return $factory->createResponse(
                $response->getStatusCode(),
                $response->getHeaders(),
                Utils::jsonEncode($result)
            );
        }, $results);
    }
}