PhpJsonRpc\Server\Request\RequestBuilder

Complexity

Total Complexity

17

Size/Duplication

Total Lines	114
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	5

Test Coverage

Coverage

75.56%

Importance

Changes	1
Bugs	1	Features	0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	4
A	isBatchRequest()	0	4	1
A	decodedJson()	0	4	1
A	buildRequest()	0	14	3
A	assembleJsonSchemaValidator()	0	8	1
C	buildJsonErrorMessage()	0	27	7

<?php

namespace PhpJsonRpc\Server\Request;

use PhpJsonRpc\Server\Error\ParseError;
use PhpJsonRpc\Server\Error\InvalidRequest;
use JsonSchema\Validator as JsonSchemaValidator;

class RequestBuilder
{
    const JSON_SCHEMA_PATH = '/../../jsonschemas/request.json';

    /**
     * @var mixed should be object or array
     */
    protected $decodedJson;

    /**
     * @param string $jsonRpcMessage
     *
     * @throws InvalidRequest
     * @throws ParseError
     */
    public function __construct($jsonRpcMessage)
    {
        $this->decodedJson  = json_decode($jsonRpcMessage);
        $jsonLastError      = json_last_error();

        if ($jsonLastError !== JSON_ERROR_NONE) {
            throw new ParseError($this->buildJsonErrorMessage($jsonLastError));
        }

        if ($this->isBatchRequest() && !$this->decodedJson()) {
            throw new InvalidRequest;
        }
    }

    /**
     * @return bool
     */
    public function isBatchRequest()
    {
        return is_array($this->decodedJson);
    }

    /**
     * @return mixed should be object or array
     */
    public function decodedJson()
    {
        return $this->decodedJson;
    }

    /**
     * @param object $jsonObject
     *
     * @return AbstractRequest NotificationRequest|Request
     *
     * @throws InvalidRequest
     */
    public function buildRequest($jsonObject)
    {
        $jsonSchemaValidator = $this->assembleJsonSchemaValidator($jsonObject);

        if ($jsonSchemaValidator->isValid() === false) {
            throw new InvalidRequest($jsonSchemaValidator->getErrors());
        }

        if (property_exists($jsonObject, 'id')) {
            return new Request($jsonObject);
        }

        return new NotificationRequest($jsonObject);
    }

    /**
     * @param mixed $jsonDecodedMessage
     *
     * @return JsonSchemaValidator
     */
    protected function assembleJsonSchemaValidator($jsonDecodedMessage)
    {
        $validator = new JsonSchemaValidator;

        $validator->check($jsonDecodedMessage, (object)['$ref' => 'file://' . __DIR__ . self::JSON_SCHEMA_PATH]);

        return $validator;
    }

    /**
     * @param int $jsonLastError
     *
     * @return string
     */
    protected function buildJsonErrorMessage($jsonLastError)
    {
        $message = 'Unknown error';

        switch ($jsonLastError) {
            case JSON_ERROR_NONE:
                $message = 'No errors';
                break;
            case JSON_ERROR_DEPTH:
                $message = 'Maximum stack depth exceeded';
                break;
            case JSON_ERROR_STATE_MISMATCH:
                $message = 'Underflow or the modes mismatch';
                break;
            case JSON_ERROR_CTRL_CHAR:
                $message = 'Unexpected control character found';
                break;
            case JSON_ERROR_SYNTAX:
                $message = 'Syntax error, malformed JSON';
                break;
            case JSON_ERROR_UTF8:
                $message = 'Malformed UTF-8 characters, possibly incorrectly encoded';
                break;
        }

        return $message;
    }
}