dependabot-composer 0.106.4 → 0.106.5

data/helpers/vendor/justinrainbow/json-schema/src/JsonSchema/Uri/Retrievers/PredefinedArray.php

@@ -0,0 +1,56 @@
+<?php
+
+namespace JsonSchema\Uri\Retrievers;
+
+use JsonSchema\Validator;
+
+/**
+ * URI retrieved based on a predefined array of schemas
+ *
+ * @example
+ *
+ *      $retriever = new PredefinedArray(array(
+ *          'http://acme.com/schemas/person#'  => '{ ... }',
+ *          'http://acme.com/schemas/address#' => '{ ... }',
+ *      ))
+ *
+ *      $schema = $retriever->retrieve('http://acme.com/schemas/person#');
+ */
+class PredefinedArray extends AbstractRetriever
+{
+    /**
+     * Contains schemas as URI => JSON
+     *
+     * @var array
+     */
+    private $schemas;
+
+    /**
+     * Constructor
+     *
+     * @param array  $schemas
+     * @param string $contentType
+     */
+    public function __construct(array $schemas, $contentType = Validator::SCHEMA_MEDIA_TYPE)
+    {
+        $this->schemas     = $schemas;
+        $this->contentType = $contentType;
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \JsonSchema\Uri\Retrievers\UriRetrieverInterface::retrieve()
+     */
+    public function retrieve($uri)
+    {
+        if (!array_key_exists($uri, $this->schemas)) {
+            throw new \JsonSchema\Exception\ResourceNotFoundException(sprintf(
+                'The JSON schema "%s" was not found.',
+                $uri
+            ));
+        }
+
+        return $this->schemas[$uri];
+    }
+}

data/helpers/vendor/justinrainbow/json-schema/src/JsonSchema/Uri/Retrievers/UriRetrieverInterface.php

@@ -0,0 +1,36 @@
+<?php
+
+/*
+ * 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 JsonSchema\Uri\Retrievers;
+
+/**
+ * Interface for URI retrievers
+ *
+ * @author Sander Coolen <sander@jibber.nl>
+ */
+interface UriRetrieverInterface
+{
+    /**
+     * Retrieve a schema from the specified URI
+     *
+     * @param string $uri URI that resolves to a JSON schema
+     *
+     * @throws \JsonSchema\Exception\ResourceNotFoundException
+     *
+     * @return mixed string|null
+     */
+    public function retrieve($uri);
+
+    /**
+     * Get media content type
+     *
+     * @return string
+     */
+    public function getContentType();
+}

data/helpers/vendor/justinrainbow/json-schema/src/JsonSchema/Uri/UriResolver.php

@@ -0,0 +1,175 @@
+<?php
+
+/*
+ * 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 JsonSchema\Uri;
+
+use JsonSchema\Exception\UriResolverException;
+use JsonSchema\UriResolverInterface;
+
+/**
+ * Resolves JSON Schema URIs
+ *
+ * @author Sander Coolen <sander@jibber.nl>
+ */
+class UriResolver implements UriResolverInterface
+{
+    /**
+     * Parses a URI into five main components
+     *
+     * @param string $uri
+     *
+     * @return array
+     */
+    public function parse($uri)
+    {
+        preg_match('|^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?|', $uri, $match);
+
+        $components = array();
+        if (5 < count($match)) {
+            $components =  array(
+                '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) && strlen($components['query'])) {
+            $uri .= '?' . $components['query'];
+        }
+        if (array_key_exists('fragment', $components)) {
+            $uri .= '#' . $components['fragment'];
+        }
+
+        return $uri;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolve($uri, $baseUri = null)
+    {
+        // treat non-uri base as local file path
+        if (
+            !is_null($baseUri) &&
+            !filter_var($baseUri, \FILTER_VALIDATE_URL) &&
+            !preg_match('|^[^/]+://|u', $baseUri)
+        ) {
+            if (is_file($baseUri)) {
+                $baseUri = 'file://' . realpath($baseUri);
+            } elseif (is_dir($baseUri)) {
+                $baseUri = 'file://' . realpath($baseUri) . '/';
+            } else {
+                $baseUri = 'file://' . getcwd() . '/' . $baseUri;
+            }
+        }
+
+        if ($uri == '') {
+            return $baseUri;
+        }
+
+        $components = $this->parse($uri);
+        $path = $components['path'];
+
+        if (!empty($components['scheme'])) {
+            return $uri;
+        }
+        $baseComponents = $this->parse($baseUri);
+        $basePath = $baseComponents['path'];
+
+        $baseComponents['path'] = self::combineRelativePathWithBasePath($path, $basePath);
+        if (isset($components['fragment'])) {
+            $baseComponents['fragment'] = $components['fragment'];
+        }
+
+        return $this->generate($baseComponents);
+    }
+
+    /**
+     * Tries to glue a relative path onto an absolute one
+     *
+     * @param string $relativePath
+     * @param string $basePath
+     *
+     * @throws UriResolverException
+     *
+     * @return string Merged path
+     */
+    public static function combineRelativePathWithBasePath($relativePath, $basePath)
+    {
+        $relativePath = self::normalizePath($relativePath);
+        if ($relativePath == '') {
+            return $basePath;
+        }
+        if ($relativePath[0] == '/') {
+            return $relativePath;
+        }
+
+        $basePathSegments = explode('/', $basePath);
+
+        preg_match('|^/?(\.\./(?:\./)*)*|', $relativePath, $match);
+        $numLevelUp = strlen($match[0]) /3 + 1;
+        if ($numLevelUp >= count($basePathSegments)) {
+            throw new UriResolverException(sprintf("Unable to resolve URI '%s' from base '%s'", $relativePath, $basePath));
+        }
+
+        $basePathSegments = array_slice($basePathSegments, 0, -$numLevelUp);
+        $path = preg_replace('|^/?(\.\./(\./)*)*|', '', $relativePath);
+
+        return implode('/', $basePathSegments) . '/' . $path;
+    }
+
+    /**
+     * Normalizes a URI path component by removing dot-slash and double slashes
+     *
+     * @param string $path
+     *
+     * @return string
+     */
+    private static function normalizePath($path)
+    {
+        $path = preg_replace('|((?<!\.)\./)*|', '', $path);
+        $path = preg_replace('|//|', '/', $path);
+
+        return $path;
+    }
+
+    /**
+     * @param string $uri
+     *
+     * @return bool
+     */
+    public function isValid($uri)
+    {
+        $components = $this->parse($uri);
+
+        return !empty($components);
+    }
+}

data/helpers/vendor/justinrainbow/json-schema/src/JsonSchema/Uri/UriRetriever.php

@@ -0,0 +1,330 @@
+<?php
+
+/*
+ * 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 JsonSchema\Uri;
+
+use JsonSchema\Exception\InvalidSchemaMediaTypeException;
+use JsonSchema\Exception\JsonDecodingException;
+use JsonSchema\Exception\ResourceNotFoundException;
+use JsonSchema\Uri\Retrievers\FileGetContents;
+use JsonSchema\Uri\Retrievers\UriRetrieverInterface;
+use JsonSchema\UriRetrieverInterface as BaseUriRetrieverInterface;
+use JsonSchema\Validator;
+
+/**
+ * Retrieves JSON Schema URIs
+ *
+ * @author Tyler Akins <fidian@rumkin.com>
+ */
+class UriRetriever implements BaseUriRetrieverInterface
+{
+    /**
+     * @var array Map of URL translations
+     */
+    protected $translationMap = array(
+        // use local copies of the spec schemas
+        '|^https?://json-schema.org/draft-(0[34])/schema#?|' => 'package://dist/schema/json-schema-draft-$1.json'
+    );
+
+    /**
+     * @var null|UriRetrieverInterface
+     */
+    protected $uriRetriever = null;
+
+    /**
+     * @var array|object[]
+     *
+     * @see loadSchema
+     */
+    private $schemaCache = array();
+
+    /**
+     * 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, array(Validator::SCHEMA_MEDIA_TYPE, 'application/json'))) {
+            return;
+        }
+
+        if (substr($uri, 0, 23) == 'http://json-schema.org/') {
+            //HACK; they deliver broken content types
+            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 = array();
+        if (5 < count($match)) {
+            $components =  array(
+                '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;
+    }
+}