PhpJsonRpc\Client\ResponseParser

Complexity

Total Complexity

27

Size/Duplication

Total Lines	149
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Importance

Changes

0

8 Methods

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

<?php

namespace PhpJsonRpc\Client;

use PhpJsonRpc\Client\ResponseParser\ParserContainer;
use PhpJsonRpc\Common\Interceptor\Interceptor;
use PhpJsonRpc\Core\Result\AbstractResult;
use PhpJsonRpc\Core\Result\Error;
use PhpJsonRpc\Core\Result\Result;
use PhpJsonRpc\Core\ResultSpec;
use PhpJsonRpc\Error\BaseClientException;
use PhpJsonRpc\Error\JsonRpcException;
use PhpJsonRpc\Error\InvalidParamsException;
use PhpJsonRpc\Error\InvalidRequestException;
use PhpJsonRpc\Error\MethodNotFoundException;
use PhpJsonRpc\Error\ParseErrorException;
use PhpJsonRpc\Error\ServerErrorException;
use PhpJsonRpc\Error\InvalidResponseException;

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

    /**
     * @var array
     */
    private $exceptionMap = [
        JsonRpcException::PARSE_ERROR      => ParseErrorException::class,
        JsonRpcException::INVALID_REQUEST  => InvalidRequestException::class,
        JsonRpcException::METHOD_NOT_FOUND => MethodNotFoundException::class,
        JsonRpcException::INVALID_PARAMS   => InvalidParamsException::class
    ];

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

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

        if (!is_array($data)) {
            throw new BaseClientException('Parse error', JsonRpcException::PARSE_ERROR);
        }

        $units = [];

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

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

        return new ResultSpec($units, false);
    }

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

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

        if ($this->isValidResult($record)) {
            $unit = new Result($record['id'], $record['result']);
        } elseif ($this->isValidError($record)) {
            $exceptionClass = $this->exceptionMap[$record['error']['code']] ?? ServerErrorException::class;
            $unit = new Error($record['id'], new $exceptionClass(
                $record['error']['data']['message'] ?? $record['error']['message'] ?? 'Server error',
                $record['error']['data']['code'] ?? 0
            ));
        } else {
            throw new InvalidResponseException();
        }

        return $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
    {
        $result = $this->preParse->handle(new ParserContainer($this, $data));

        if ($result instanceof ParserContainer) {
            return $result->getValue();
        }

        throw new \RuntimeException();
    }
}