UMA\JsonRpc\Internal\Input

Complexity

Total Complexity

12

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Test Coverage

Coverage

86.67%

Importance

Changes	3
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	isRpcRequest()	0	3	1
A	__construct()	0	26	2
A	fromString()	0	11	4
A	isArray()	0	3	2
A	parsable()	0	3	1
A	data()	0	3	1
A	fromSafeData()	0	5	1

<?php

declare(strict_types=1);

namespace UMA\JsonRpc\Internal;

use stdClass;

final class Input
{
    /**
     * @var stdClass
     */
    private static $schema;

    /**
     * @var mixed
     */
    private $data;

    /**
     * @var int
     */
    private $error;

    private function __construct($data, int $error)
    {
        $this->data = $data;
        $this->error = $error;

        // This is the minimal schema that all incoming payloads must
        // conform to in order to be considered well-formed JSON-RPC requests.
        if (!self::$schema instanceof stdClass) {

self::schema is always a sub-type of stdClass.

            self::$schema = (object)[
                '$schema' => 'https://json-schema.org/draft-07/schema#',
                'description' => 'JSON-RPC 2.0 single request schema',
                'type' => 'object',
                'required' => ['jsonrpc', 'method'],
                'additionalProperties' => false,
                'properties' => (object)[
                    'jsonrpc' => (object)[
                        'enum' => ['2.0']
                    ],
                    'method' => (object)[
                        'type' => 'string'
                    ],
                    'params' => (object)[
                        'type' => ['array', 'object']
                    ],
                    'id' => (object)[
                        'type' => ['integer', 'string']
                    ],
                ]
            ];
        }
    }

    public static function fromString(string $raw, bool $simdJson): Input
    {
        if (!$simdJson || !\extension_loaded('simdjson')) {
            return new self(\json_decode($raw), \json_last_error());
        }

        if (!\simdjson_isvalid($raw)) {

The function simdjson_isvalid was not found. Maybe you did not declare it correctly or list all dependencies?

            return new self(null, JSON_ERROR_SYNTAX);
        }

        return new self(\simdjson_decode($raw), JSON_ERROR_NONE);

The function simdjson_decode was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    public static function fromSafeData($data): Input
    {
        \assert(false !== \json_encode($data));

        return new self($data, JSON_ERROR_NONE);
    }

    public function data()
    {
        return $this->data;
    }

    public function parsable(): bool
    {
        return JSON_ERROR_NONE === $this->error;
    }

    public function isArray(): bool
    {
        return \is_array($this->data) && !empty($this->data);
    }

    public function isRpcRequest(): bool
    {
        return Validator::validate(self::$schema, $this->data);
    }
}