Na}{

File Content: `UriRetriever.php`

<?php

declare (strict_types=1);
/*
 * This file is part of the JsonSchema package.
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace PleskAdvisor\JsonSchema\Uri;

use PleskAdvisor\JsonSchema\Exception\InvalidSchemaMediaTypeException;
use PleskAdvisor\JsonSchema\Exception\JsonDecodingException;
use PleskAdvisor\JsonSchema\Exception\ResourceNotFoundException;
use PleskAdvisor\JsonSchema\Uri\Retrievers\FileGetContents;
use PleskAdvisor\JsonSchema\Uri\Retrievers\UriRetrieverInterface;
use PleskAdvisor\JsonSchema\UriRetrieverInterface as BaseUriRetrieverInterface;
use PleskAdvisor\JsonSchema\Validator;
/**
 * Retrieves JSON Schema URIs
 *
 * @author Tyler Akins <fidian@rumkin.com>
 */
class UriRetriever implements BaseUriRetrieverInterface
{
    /**
     * @var array Map of URL translations
     */
    protected $translationMap = [
        // use local copies of the spec schemas
        '|^https?://json-schema.org/draft-(0[34])/schema#?|' => 'package://dist/schema/json-schema-draft-$1.json',
    ];
    /**
     * @var array A list of endpoints for media type check exclusion
     */
    protected $allowedInvalidContentTypeEndpoints = ['http://json-schema.org/', 'https://json-schema.org/'];
    /**
     * @var null|UriRetrieverInterface
     */
    protected $uriRetriever = null;
    /**
     * @var array|object[]
     *
     * @see loadSchema
     */
    private $schemaCache = [];
    /**
     * Adds an endpoint to the media type validation exclusion list
     *
     * @param string $endpoint
     */
    public function addInvalidContentTypeEndpoint($endpoint)
    {
        $this->allowedInvalidContentTypeEndpoints[] = $endpoint;
    }
    /**
     * Guarantee the correct media type was encountered
     *
     * @param UriRetrieverInterface $uriRetriever
     * @param string                $uri
     *
     * @return bool|void
     */
    public function confirmMediaType($uriRetriever, $uri)
    {
        $contentType = $uriRetriever->getContentType();
        if (\is_null($contentType)) {
            // Well, we didn't get an invalid one
            return;
        }
        if (\in_array($contentType, [Validator::SCHEMA_MEDIA_TYPE, 'application/json'])) {
            return;
        }
        foreach ($this->allowedInvalidContentTypeEndpoints as $endpoint) {
            if (!\is_null($uri) && \strpos($uri, $endpoint) === 0) {
                return \true;
            }
        }
        throw new InvalidSchemaMediaTypeException(\sprintf('Media type %s expected', Validator::SCHEMA_MEDIA_TYPE));
    }
    /**
     * Get a URI Retriever
     *
     * If none is specified, sets a default FileGetContents retriever and
     * returns that object.
     *
     * @return UriRetrieverInterface
     */
    public function getUriRetriever()
    {
        if (\is_null($this->uriRetriever)) {
            $this->setUriRetriever(new FileGetContents());
        }
        return $this->uriRetriever;
    }
    /**
     * Resolve a schema based on pointer
     *
     * URIs can have a fragment at the end in the format of
     * #/path/to/object and we are to look up the 'path' property of
     * the first object then the 'to' and 'object' properties.
     *
     * @param object $jsonSchema JSON Schema contents
     * @param string $uri        JSON Schema URI
     *
     * @throws ResourceNotFoundException
     *
     * @return object JSON Schema after walking down the fragment pieces
     */
    public function resolvePointer($jsonSchema, $uri)
    {
        $resolver = new UriResolver();
        $parsed = $resolver->parse($uri);
        if (empty($parsed['fragment'])) {
            return $jsonSchema;
        }
        $path = \explode('/', $parsed['fragment']);
        while ($path) {
            $pathElement = \array_shift($path);
            if (!empty($pathElement)) {
                $pathElement = \str_replace('~1', '/', $pathElement);
                $pathElement = \str_replace('~0', '~', $pathElement);
                if (!empty($jsonSchema->{$pathElement})) {
                    $jsonSchema = $jsonSchema->{$pathElement};
                } else {
                    throw new ResourceNotFoundException('Fragment "' . $parsed['fragment'] . '" not found' . ' in ' . $uri);
                }
                if (!\is_object($jsonSchema)) {
                    throw new ResourceNotFoundException('Fragment part "' . $pathElement . '" is no object ' . ' in ' . $uri);
                }
            }
        }
        return $jsonSchema;
    }
    /**
     * {@inheritdoc}
     */
    public function retrieve($uri, $baseUri = null, $translate = \true)
    {
        $resolver = new UriResolver();
        $resolvedUri = $fetchUri = $resolver->resolve($uri, $baseUri);
        //fetch URL without #fragment
        $arParts = $resolver->parse($resolvedUri);
        if (isset($arParts['fragment'])) {
            unset($arParts['fragment']);
            $fetchUri = $resolver->generate($arParts);
        }
        // apply URI translations
        if ($translate) {
            $fetchUri = $this->translate($fetchUri);
        }
        $jsonSchema = $this->loadSchema($fetchUri);
        // Use the JSON pointer if specified
        $jsonSchema = $this->resolvePointer($jsonSchema, $resolvedUri);
        if ($jsonSchema instanceof \stdClass) {
            $jsonSchema->id = $resolvedUri;
        }
        return $jsonSchema;
    }
    /**
     * Fetch a schema from the given URI, json-decode it and return it.
     * Caches schema objects.
     *
     * @param string $fetchUri Absolute URI
     *
     * @return object JSON schema object
     */
    protected function loadSchema($fetchUri)
    {
        if (isset($this->schemaCache[$fetchUri])) {
            return $this->schemaCache[$fetchUri];
        }
        $uriRetriever = $this->getUriRetriever();
        $contents = $this->uriRetriever->retrieve($fetchUri);
        $this->confirmMediaType($uriRetriever, $fetchUri);
        $jsonSchema = \json_decode($contents);
        if (\JSON_ERROR_NONE < ($error = \json_last_error())) {
            throw new JsonDecodingException($error);
        }
        $this->schemaCache[$fetchUri] = $jsonSchema;
        return $jsonSchema;
    }
    /**
     * Set the URI Retriever
     *
     * @param UriRetrieverInterface $uriRetriever
     *
     * @return $this for chaining
     */
    public function setUriRetriever(UriRetrieverInterface $uriRetriever)
    {
        $this->uriRetriever = $uriRetriever;
        return $this;
    }
    /**
     * Parses a URI into five main components
     *
     * @param string $uri
     *
     * @return array
     */
    public function parse($uri)
    {
        \preg_match('|^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\\?([^#]*))?(#(.*))?|', $uri, $match);
        $components = [];
        if (5 < \count($match)) {
            $components = ['scheme' => $match[2], 'authority' => $match[4], 'path' => $match[5]];
        }
        if (7 < \count($match)) {
            $components['query'] = $match[7];
        }
        if (9 < \count($match)) {
            $components['fragment'] = $match[9];
        }
        return $components;
    }
    /**
     * Builds a URI based on n array with the main components
     *
     * @param array $components
     *
     * @return string
     */
    public function generate(array $components)
    {
        $uri = $components['scheme'] . '://' . $components['authority'] . $components['path'];
        if (\array_key_exists('query', $components)) {
            $uri .= $components['query'];
        }
        if (\array_key_exists('fragment', $components)) {
            $uri .= $components['fragment'];
        }
        return $uri;
    }
    /**
     * Resolves a URI
     *
     * @param string $uri     Absolute or relative
     * @param string $baseUri Optional base URI
     *
     * @return string
     */
    public function resolve($uri, $baseUri = null)
    {
        $components = $this->parse($uri);
        $path = $components['path'];
        if (\array_key_exists('scheme', $components) && 'http' === $components['scheme']) {
            return $uri;
        }
        $baseComponents = $this->parse($baseUri);
        $basePath = $baseComponents['path'];
        $baseComponents['path'] = UriResolver::combineRelativePathWithBasePath($path, $basePath);
        return $this->generate($baseComponents);
    }
    /**
     * @param string $uri
     *
     * @return bool
     */
    public function isValid($uri)
    {
        $components = $this->parse($uri);
        return !empty($components);
    }
    /**
     * Set a URL translation rule
     */
    public function setTranslation($from, $to)
    {
        $this->translationMap[$from] = $to;
    }
    /**
     * Apply URI translation rules
     */
    public function translate($uri)
    {
        foreach ($this->translationMap as $from => $to) {
            $uri = \preg_replace($from, $to, $uri);
        }
        // translate references to local files within the json-schema package
        $uri = \preg_replace('|^package://|', \sprintf('file://%s/', \realpath(__DIR__ . '/../../..')), $uri);
        return $uri;
    }
}
Name	Size	Permission
Retrievers	---	0755
UriResolver.php	5304 bytes	0644
UriRetriever.php	9241 bytes	0644
File Content: UriRetriever.php

File Content: `UriRetriever.php`
