Rebilly\OpenAPI\Schema

Complexity

Total Complexity

41

Size/Duplication

Total Lines	231
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

100%

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	16	3
A	getVersion()	0	4	1
A	getServers()	0	4	1
A	getDefinition()	0	4	1
A	getDefinitionNames()	0	4	1
A	getPathSchema()	0	4	1
A	getAvailablePaths()	0	4	1
A	getAllowedMethods()	0	15	1
A	getRequestHeaderSchemas()	0	11	2
A	isRequestBodyDefined()	0	4	1
A	getRequestBodySchema()	0	18	4
A	getRequestPathParameters()	0	4	1
A	getRequestQueryParameters()	0	4	1
A	getRequestContentTypes()	0	4	1
A	isResponseDefined()	0	4	1
A	isResponseBodyDefined()	0	4	1
A	getResponseContentTypes()	0	4	1
A	getResponseHeaderSchemas()	0	18	4
A	getResponseBodySchema()	0	18	4
A	fetch()	0	8	2
A	encodePath()	0	4	1
A	normalizeMethod()	0	4	1
A	getRequestParameters()	0	14	1
A	normalizeRequestParameters()	0	23	5

<?php
/**
 * This file is part of Rebilly.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 *
 * @see http://rebilly.com
 */

namespace Rebilly\OpenAPI;

use InvalidArgumentException;
use JsonSchema\Exception\UnresolvableJsonPointerException;
use JsonSchema\SchemaStorage;
use JsonSchema\Uri\UriResolver;
use JsonSchema\Uri\UriRetriever;
use stdClass;

final class Schema
{
    private $schemaStorage;

    private $uri;

    public function __construct(string $uri)
    {
        if (strpos($uri, '//') === false) {
            $uri = "file://{$uri}";
        }

        $schemaStorage = new SchemaStorage(new UriRetriever(), new UriResolver());
        $schemaStorage->addSchema($uri);

        $this->schemaStorage = $schemaStorage;
        $this->uri = $uri;

        if (!preg_match('|3\.0(\.\d+)?|', $this->getVersion())) {
            throw new UnexpectedValueException('Unsupported OpenAPI Specification schema');
        }
    }

    public function getVersion(): string
    {
        return $this->fetch('#/openapi');
    }

    public function getServers(): array
    {
        return array_column($this->fetch('#/servers'), 'url');
    }

    public function getDefinition(string $name): stdClass
    {
        return $this->fetch("#/components/schemas/{$name}");
    }

    public function getDefinitionNames(): array
    {
        return array_keys((array) $this->fetch('#/components/schemas'));
    }

    public function getPathSchema(string $path): stdClass
    {
        return $this->fetch("#/paths/{$this->encodePath($path)}");
    }

    public function getAvailablePaths(): array
    {
        return array_keys((array) $this->fetch('#/paths'));
    }

    public function getAllowedMethods(string $path): array
    {
        $schema = $this->getPathSchema($path);
        $methods = [
            'OPTIONS' => true,
            'HEAD' => isset($schema->get),
            'GET' => isset($schema->get),
            'POST' => isset($schema->post),
            'PUT' => isset($schema->put),
            'DELETE' => isset($schema->delete),
            'PATCH' => isset($schema->patch),
        ];

        return array_keys(array_filter($methods));
    }

    public function getRequestHeaderSchemas(string $path, string $method): array
    {
        $parameters = $this->getRequestParameters($path, $method, 'header');
        $headers = [];

        foreach ($parameters as $parameter) {
            $headers[] = $parameter->schema;
        }

        return $headers;
    }

    public function isRequestBodyDefined(string $path, string $method): bool
    {
        return $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/requestBody/content") !== null;
    }

    public function getRequestBodySchema(string $path, string $method, string $contentType = null): ?stdClass
    {
        $schemas = $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/requestBody/content");

        if (empty($schemas)) {
            return null;
        }

        if (!$contentType) {

The expression $contentType of type null|string is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

            return reset($schemas)->schema;
        }

        if (!isset($schemas->{$contentType})) {
            throw new InvalidArgumentException('Unsupported request content type');
        }

        return $schemas->{$contentType}->schema;
    }

    public function getRequestPathParameters(string $path, string $method): array
    {
        return $this->getRequestParameters($path, $method, 'path');
    }

    public function getRequestQueryParameters(string $path, string $method): array
    {
        return $this->getRequestParameters($path, $method, 'query');
    }

    public function getRequestContentTypes(string $path, string $method): array
    {
        return array_keys((array) $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/requestBody/content"));
    }

    public function isResponseDefined(string $path, string $method, string $status): bool
    {
        return $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/responses/{$status}") !== null;
    }

    public function isResponseBodyDefined(string $path, string $method, string $status): bool
    {
        return $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/responses/{$status}/content") !== null;
    }

    public function getResponseContentTypes(string $path, string $method, string $status): array
    {
        return array_keys((array) $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/responses/{$status}/content"));
    }

    public function getResponseHeaderSchemas(string $path, string $method, string $status): array
    {
        $headers = (array) $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/responses/{$status}/headers");

        foreach ($headers as &$header) {
            if (isset($header->{'$ref'})) {
                $header = $this->schemaStorage->resolveRef($header->{'$ref'});
            }

            if (isset($header->schema->{'$ref'})) {
                $header->schema = $this->schemaStorage->resolveRef($header->schema->{'$ref'});
            }

            $header = $header->schema;
        }

        return $headers;
    }

    public function getResponseBodySchema(string $path, string $method, string $status, string $contentType = null): ?stdClass
    {
        $schemas = $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/responses/{$status}/content");

        if (empty($schemas)) {
            return null;
        }

        if (!$contentType) {

The expression $contentType of type null|string is loosely compared to false; this is ambiguous if the string can be empty. You might want to explicitly use === null instead.

            return reset($schemas)->schema;
        }

        if (!isset($schemas->{$contentType})) {
            throw new InvalidArgumentException('Unsupported response content type');
        }

        return $schemas->{$contentType}->schema;
    }

    private function fetch(string $path)
    {
        try {
            return $this->schemaStorage->resolveRef(sprintf("%s%s", $this->uri, $path));
        } catch (UnresolvableJsonPointerException $e) {
            return null;
        }
    }

    private function encodePath(string $path): string
    {
        return strtr($path, ['/' => '~1', '~' => '~0', '%' => '%25']);
    }

    private function normalizeMethod(string $method): string
    {
        return strtolower($method);
    }

    private function getRequestParameters(string $path, string $method, string $location): array
    {
        $operationParameters = $this->normalizeRequestParameters(
            (array) $this->fetch("#/paths/{$this->encodePath($path)}/{$this->normalizeMethod($method)}/parameters"),
            $location
        );

        $pathParameters = $this->normalizeRequestParameters(
            (array) $this->fetch("#/paths/{$this->encodePath($path)}/parameters"),
            $location
        );

        return $operationParameters + $pathParameters;
    }

    private function normalizeRequestParameters(array $parameters, string $location): array
    {
        $schemas = [];

        foreach ($parameters as &$parameter) {
            if (isset($parameter->{'$ref'})) {
                $parameter = $this->schemaStorage->resolveRef($parameter->{'$ref'});
            }

            if ($parameter->in !== $location) {
                continue;
            }

            if (isset($parameter->schema->{'$ref'})) {
                $parameter->schema = $this->schemaStorage->resolveRef($parameter->schema->{'$ref'});
            }

            $schemas[$parameter->name] = clone $parameter;
            unset($schemas[$parameter->name]->name, $schemas[$parameter->name]->in);
        }

        return $schemas;
    }
}