Yoanm\JsonRpcServer\Infra\Serialization\RawRequestSerializer

Complexity

Total Complexity

14

Size/Duplication

Total Lines	112
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	populateItem()	0	12	4
A	denormalize()	0	9	1
A	__construct()	0	3	1
B	decode()	0	23	4
A	guessBatchOrNot()	0	16	3
A	deserialize()	0	4	1

<?php

namespace Yoanm\JsonRpcServer\Infra\Serialization;

use Yoanm\JsonRpcServer\App\Serialization\RequestDenormalizer;
use Yoanm\JsonRpcServer\Domain\Exception\JsonRpcInvalidRequestException;
use Yoanm\JsonRpcServer\Domain\Exception\JsonRpcParseErrorException;
use Yoanm\JsonRpcServer\Infra\RawObject\JsonRpcRawRequest;

/**
 * Class RawRequestSerializer
 */
class RawRequestSerializer
{
    /** @var RequestDenormalizer */
    private $requestDenormalizer;

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

    /**
     * @param string $content
     *
     * @return JsonRpcRawRequest
     */
    public function deserialize(string $content) : JsonRpcRawRequest
    {
        return $this->denormalize(
            $this->decode($content)
        );
    }

    /**
     * @param string $requestContent
     *
     * @return array Decoded content
     *
     * @throws JsonRpcParseErrorException
     */
    public function decode(string $requestContent) : array
    {
        $decodedContent = json_decode($requestContent, true);

        // Check if parsing is ok => Parse error
        if (JSON_ERROR_NONE !== json_last_error()) {
            throw new JsonRpcParseErrorException(
                $requestContent,
                json_last_error(),
                json_last_error_msg()
            );
        }

        // Content must be either an array (normal request) or an array of array (batch request)
        //  => so must be an array
        // In case it's a batch call, at least one sub request must exist
        // and in case not, some required properties must exist
        // => array must have at least one child
        if (!is_array($decodedContent) || count($decodedContent) === 0) {
            throw new JsonRpcInvalidRequestException($requestContent);
        }

        return $decodedContent;
    }

    /**
     * @param array $decodedContent
     *
     * @return JsonRpcRawRequest
     */
    public function denormalize(array $decodedContent) : JsonRpcRawRequest
    {
        $isBatch = $this->guessBatchOrNot($decodedContent);

        $rawRequest = new JsonRpcRawRequest($isBatch);

        $this->populateItem($rawRequest, $decodedContent);

        return $rawRequest;
    }

    /**
     * @param array $decodedContent
     *
     * @return bool
     */
    private function guessBatchOrNot(array $decodedContent)
    {
        $isBatch = true;
        // Loop over each items
        // -> In case it's a valid batch request -> all keys will have numeric type -> iterations = Number of requests
        // -> In case it's a valid normal request -> all keys will have string type -> iterations = 1 (stopped on #1)
        // => Better performance for normal request (Probably most of requests)
        foreach ($decodedContent as $key => $item) {
            // At least a key is a string (that do not contain an int)
            if (!is_int($key)) {
                $isBatch = false;
                break;
            }
        }

        return $isBatch;
    }

    /**
     * @param JsonRpcRawRequest $rawRequest
     * @param array $decodedContent
     */
    private function populateItem(JsonRpcRawRequest $rawRequest, array $decodedContent)
    {
        // convert to array in any cases for simpler use
        $itemList = $rawRequest->isBatch() ? $decodedContent : [$decodedContent];
        foreach ($itemList as $item) {
            // Safely denormalize items
            try {
                $rawRequest->addRequestItem(
                    $this->requestDenormalizer->denormalize($item)
                );
            } catch (\Exception $exception) {
                $rawRequest->addExceptionItem($exception);
            }
        }
    }
}