PhpJsonRpc\Client\ResponseParser

Complexity

Total Complexity

28

Size/Duplication

Total Lines	153
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	8

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	1
B	parse()	0	22	4
A	onPreParse()	0	4	1
A	onPostParse()	0	4	1
A	decodeResult()	0	14	3
A	isSingleResponse()	0	4	1
B	isValidResult()	0	12	5
B	isValidError()	0	14	10
A	preParse()	0	4	1
A	postParse()	0	4	1

<?php

namespace PhpJsonRpc\Client;

use PhpJsonRpc\Common\Chain\Chain;
use PhpJsonRpc\Common\Chain\Container;
use PhpJsonRpc\Core\Result\AbstractResult;
use PhpJsonRpc\Core\Result\ResultError;
use PhpJsonRpc\Core\Result\ResultUnit;
use PhpJsonRpc\Core\ResultSpecifier;
use PhpJsonRpc\Error\ServerErrorException;
use PhpJsonRpc\Error\ParseErrorException;
use PhpJsonRpc\Error\InvalidResponseException;

class ResponseParser
{
    /**
     * @var Chain
     */
    private $preParse;

    /**
     * @var Chain
     */
    private $postParse;

    /**
     * ResponseParser constructor.
     */
    public function __construct()
    {
        $this->preParse  = Chain::createBase();
        $this->postParse = Chain::createBase();
    }

    /**
     * @param string $payload
     *
     * @return ResultSpecifier
     */
    public function parse(string $payload): ResultSpecifier
    {
        $data = @json_decode($payload, true);

        if (!is_array($data)) {
            throw new ParseErrorException();
        }

        $units = [];

        if ($this->isSingleResponse($data)) {
            $units[] = $this->decodeResult($data);
            return new ResultSpecifier($units, true);
        }

        /** @var array $data */
        foreach ($data as $response) {
            $units[] = $this->decodeResult($response);
        }

        return new ResultSpecifier($units, false);
    }

    /**
     * @return Chain
     */
    public function onPreParse(): Chain
    {
        return $this->preParse;
    }

    /**
     * @return Chain
     */
    public function onPostParse(): Chain
    {
        return $this->postParse;
    }

    /**
     * @param array $record
     *
     * @return AbstractResult
     */
    private function decodeResult(array $record): AbstractResult
    {
        $record = $this->preParse($record);

        if ($this->isValidResult($record)) {
            $unit = new ResultUnit($record['id'], $record['result']);
        } elseif ($this->isValidError($record)) {
            $unit = new ResultError($record['id'], new ServerErrorException($record['error']['message'], $record['error']['code']));
        } else {
            throw new InvalidResponseException();
        }

        return $this->postParse($unit);
    }

    /**
     * @param array $response
     *
     * @return bool
     */
    private function isSingleResponse(array $response): bool
    {
        return array_keys($response) !== range(0, count($response) - 1);
    }

    /**
     * @param array $payload
     *
     * @return bool
     */
    private function isValidResult($payload): bool
    {
        if (!is_array($payload)) {
            return false;
        }

        $headerValid = array_key_exists('jsonrpc', $payload) && $payload['jsonrpc'] === '2.0';
        $resultValid = array_key_exists('result', $payload);
        $idValid     = array_key_exists('id', $payload);

        return $headerValid && $resultValid && $idValid;
    }

    /**
     * @param array $payload
     *
     * @return bool
     */
    private function isValidError($payload): bool
    {
        if (!is_array($payload)) {
            return false;
        }

        $headerValid = array_key_exists('jsonrpc', $payload) && $payload['jsonrpc'] === '2.0';
        $errorValid  = array_key_exists('error', $payload) && is_array($payload['error'])
                       && array_key_exists('code', $payload['error']) && is_int($payload['error']['code'])
                       && array_key_exists('message', $payload['error']) && is_string($payload['error']['message']);
        $idValid     = array_key_exists('id', $payload);

        return $headerValid && $errorValid && $idValid;
    }

    /**
     * @param array $data
     *
     * @return array
     */
    private function preParse(array $data): array
    {
        return $this->preParse->handle(new Container($this, $data))->last();
    }

    /**
     * @param AbstractResult $result
     *
     * @return AbstractResult
     */
    private function postParse(AbstractResult $result): AbstractResult
    {
        return $this->postParse->handle(new Container($this, $result))->last();
    }
}