dependabot-composer 0.107.13 → 0.107.14

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

@@ -0,0 +1,30 @@
+<?php
+
+namespace JsonSchema;
+
+class Rfc3339
+{
+    const REGEX = '/^(\d{4}-\d{2}-\d{2}[T ]{1}\d{2}:\d{2}:\d{2})(\.\d+)?(Z|([+-]\d{2}):?(\d{2}))$/';
+
+    /**
+     * Try creating a DateTime instance
+     *
+     * @param string $string
+     *
+     * @return \DateTime|null
+     */
+    public static function createFromString($string)
+    {
+        if (!preg_match(self::REGEX, strtoupper($string), $matches)) {
+            return null;
+        }
+
+        $dateAndTime = $matches[1];
+        $microseconds = $matches[2] ?: '.000000';
+        $timeZone = 'Z' !== $matches[3] ? $matches[4] . ':' . $matches[5] : '+00:00';
+        $dateFormat = strpos($dateAndTime, 'T') === false ? 'Y-m-d H:i:s.uP' : 'Y-m-d\TH:i:s.uP';
+        $dateTime = \DateTime::createFromFormat($dateFormat, $dateAndTime . $microseconds . $timeZone, new \DateTimeZone('UTC'));
+
+        return $dateTime ?: null;
+    }
+}

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

@@ -0,0 +1,169 @@
+<?php
+
+namespace JsonSchema;
+
+use JsonSchema\Constraints\BaseConstraint;
+use JsonSchema\Entity\JsonPointer;
+use JsonSchema\Exception\UnresolvableJsonPointerException;
+use JsonSchema\Uri\UriResolver;
+use JsonSchema\Uri\UriRetriever;
+
+class SchemaStorage implements SchemaStorageInterface
+{
+    const INTERNAL_PROVIDED_SCHEMA_URI = 'internal://provided-schema/';
+
+    protected $uriRetriever;
+    protected $uriResolver;
+    protected $schemas = array();
+
+    public function __construct(
+        UriRetrieverInterface $uriRetriever = null,
+        UriResolverInterface $uriResolver = null
+    ) {
+        $this->uriRetriever = $uriRetriever ?: new UriRetriever();
+        $this->uriResolver = $uriResolver ?: new UriResolver();
+    }
+
+    /**
+     * @return UriRetrieverInterface
+     */
+    public function getUriRetriever()
+    {
+        return $this->uriRetriever;
+    }
+
+    /**
+     * @return UriResolverInterface
+     */
+    public function getUriResolver()
+    {
+        return $this->uriResolver;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function addSchema($id, $schema = null)
+    {
+        if (is_null($schema) && $id !== self::INTERNAL_PROVIDED_SCHEMA_URI) {
+            // if the schema was user-provided to Validator and is still null, then assume this is
+            // what the user intended, as there's no way for us to retrieve anything else. User-supplied
+            // schemas do not have an associated URI when passed via Validator::validate().
+            $schema = $this->uriRetriever->retrieve($id);
+        }
+
+        // cast array schemas to object
+        if (is_array($schema)) {
+            $schema = BaseConstraint::arrayToObjectRecursive($schema);
+        }
+
+        // workaround for bug in draft-03 & draft-04 meta-schemas (id & $ref defined with incorrect format)
+        // see https://github.com/json-schema-org/JSON-Schema-Test-Suite/issues/177#issuecomment-293051367
+        if (is_object($schema) && property_exists($schema, 'id')) {
+            if ($schema->id == 'http://json-schema.org/draft-04/schema#') {
+                $schema->properties->id->format = 'uri-reference';
+            } elseif ($schema->id == 'http://json-schema.org/draft-03/schema#') {
+                $schema->properties->id->format = 'uri-reference';
+                $schema->properties->{'$ref'}->format = 'uri-reference';
+            }
+        }
+
+        // resolve references
+        $this->expandRefs($schema, $id);
+
+        $this->schemas[$id] = $schema;
+    }
+
+    /**
+     * Recursively resolve all references against the provided base
+     *
+     * @param mixed  $schema
+     * @param string $base
+     */
+    private function expandRefs(&$schema, $base = null)
+    {
+        if (!is_object($schema)) {
+            if (is_array($schema)) {
+                foreach ($schema as &$member) {
+                    $this->expandRefs($member, $base);
+                }
+            }
+
+            return;
+        }
+
+        if (property_exists($schema, 'id') && is_string($schema->id) && $base != $schema->id) {
+            $base = $this->uriResolver->resolve($schema->id, $base);
+        }
+
+        if (property_exists($schema, '$ref') && is_string($schema->{'$ref'})) {
+            $refPointer = new JsonPointer($this->uriResolver->resolve($schema->{'$ref'}, $base));
+            $schema->{'$ref'} = (string) $refPointer;
+        }
+
+        foreach ($schema as &$member) {
+            $this->expandRefs($member, $base);
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function getSchema($id)
+    {
+        if (!array_key_exists($id, $this->schemas)) {
+            $this->addSchema($id);
+        }
+
+        return $this->schemas[$id];
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolveRef($ref)
+    {
+        $jsonPointer = new JsonPointer($ref);
+
+        // resolve filename for pointer
+        $fileName = $jsonPointer->getFilename();
+        if (!strlen($fileName)) {
+            throw new UnresolvableJsonPointerException(sprintf(
+                "Could not resolve fragment '%s': no file is defined",
+                $jsonPointer->getPropertyPathAsString()
+            ));
+        }
+
+        // get & process the schema
+        $refSchema = $this->getSchema($fileName);
+        foreach ($jsonPointer->getPropertyPaths() as $path) {
+            if (is_object($refSchema) && property_exists($refSchema, $path)) {
+                $refSchema = $this->resolveRefSchema($refSchema->{$path});
+            } elseif (is_array($refSchema) && array_key_exists($path, $refSchema)) {
+                $refSchema = $this->resolveRefSchema($refSchema[$path]);
+            } else {
+                throw new UnresolvableJsonPointerException(sprintf(
+                    'File: %s is found, but could not resolve fragment: %s',
+                    $jsonPointer->getFilename(),
+                    $jsonPointer->getPropertyPathAsString()
+                ));
+            }
+        }
+
+        return $refSchema;
+    }
+
+    /**
+     * {@inheritdoc}
+     */
+    public function resolveRefSchema($refSchema)
+    {
+        if (is_object($refSchema) && property_exists($refSchema, '$ref') && is_string($refSchema->{'$ref'})) {
+            $newSchema = $this->resolveRef($refSchema->{'$ref'});
+            $refSchema = (object) (get_object_vars($refSchema) + get_object_vars($newSchema));
+            unset($refSchema->{'$ref'});
+        }
+
+        return $refSchema;
+    }
+}

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

@@ -0,0 +1,41 @@
+<?php
+
+namespace JsonSchema;
+
+interface SchemaStorageInterface
+{
+    /**
+     * Adds schema with given identifier
+     *
+     * @param string $id
+     * @param object $schema
+     */
+    public function addSchema($id, $schema = null);
+
+    /**
+     * Returns schema for given identifier, or null if it does not exist
+     *
+     * @param string $id
+     *
+     * @return object
+     */
+    public function getSchema($id);
+
+    /**
+     * Returns schema for given reference with all sub-references resolved
+     *
+     * @param string $ref
+     *
+     * @return object
+     */
+    public function resolveRef($ref);
+
+    /**
+     * Returns schema referenced by '$ref' property
+     *
+     * @param mixed $refSchema
+     *
+     * @return object
+     */
+    public function resolveRefSchema($refSchema);
+}

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

@@ -0,0 +1,34 @@
+<?php
+/**
+ * JsonSchema
+ *
+ * @filesource
+ */
+
+namespace JsonSchema\Uri\Retrievers;
+
+/**
+ * AbstractRetriever implements the default shared behavior
+ * that all descendant Retrievers should inherit
+ *
+ * @author Steven Garcia <webwhammy@gmail.com>
+ */
+abstract class AbstractRetriever implements UriRetrieverInterface
+{
+    /**
+     * Media content type
+     *
+     * @var string
+     */
+    protected $contentType;
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \JsonSchema\Uri\Retrievers\UriRetrieverInterface::getContentType()
+     */
+    public function getContentType()
+    {
+        return $this->contentType;
+    }
+}

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

@@ -0,0 +1,83 @@
+<?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;
+
+use JsonSchema\Exception\RuntimeException;
+use JsonSchema\Validator;
+
+/**
+ * Tries to retrieve JSON schemas from a URI using cURL library
+ *
+ * @author Sander Coolen <sander@jibber.nl>
+ */
+class Curl extends AbstractRetriever
+{
+    protected $messageBody;
+
+    public function __construct()
+    {
+        if (!function_exists('curl_init')) {
+            // Cannot test this, because curl_init is present on all test platforms plus mock
+            throw new RuntimeException('cURL not installed'); // @codeCoverageIgnore
+        }
+    }
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \JsonSchema\Uri\Retrievers\UriRetrieverInterface::retrieve()
+     */
+    public function retrieve($uri)
+    {
+        $ch = curl_init();
+
+        curl_setopt($ch, CURLOPT_URL, $uri);
+        curl_setopt($ch, CURLOPT_HEADER, true);
+        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+        curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: ' . Validator::SCHEMA_MEDIA_TYPE));
+
+        $response = curl_exec($ch);
+        if (false === $response) {
+            throw new \JsonSchema\Exception\ResourceNotFoundException('JSON schema not found');
+        }
+
+        $this->fetchMessageBody($response);
+        $this->fetchContentType($response);
+
+        curl_close($ch);
+
+        return $this->messageBody;
+    }
+
+    /**
+     * @param string $response cURL HTTP response
+     */
+    private function fetchMessageBody($response)
+    {
+        preg_match("/(?:\r\n){2}(.*)$/ms", $response, $match);
+        $this->messageBody = $match[1];
+    }
+
+    /**
+     * @param string $response cURL HTTP response
+     *
+     * @return bool Whether the Content-Type header was found or not
+     */
+    protected function fetchContentType($response)
+    {
+        if (0 < preg_match("/Content-Type:(\V*)/ims", $response, $match)) {
+            $this->contentType = trim($match[1]);
+
+            return true;
+        }
+
+        return false;
+    }
+}

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

@@ -0,0 +1,93 @@
+<?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;
+
+use JsonSchema\Exception\ResourceNotFoundException;
+
+/**
+ * Tries to retrieve JSON schemas from a URI using file_get_contents()
+ *
+ * @author Sander Coolen <sander@jibber.nl>
+ */
+class FileGetContents extends AbstractRetriever
+{
+    protected $messageBody;
+
+    /**
+     * {@inheritdoc}
+     *
+     * @see \JsonSchema\Uri\Retrievers\UriRetrieverInterface::retrieve()
+     */
+    public function retrieve($uri)
+    {
+        $errorMessage = null;
+        set_error_handler(function ($errno, $errstr) use (&$errorMessage) {
+            $errorMessage = $errstr;
+        });
+        $response = file_get_contents($uri);
+        restore_error_handler();
+
+        if ($errorMessage) {
+            throw new ResourceNotFoundException($errorMessage);
+        }
+
+        if (false === $response) {
+            throw new ResourceNotFoundException('JSON schema not found at ' . $uri);
+        }
+
+        if ($response == ''
+            && substr($uri, 0, 7) == 'file://' && substr($uri, -1) == '/'
+        ) {
+            throw new ResourceNotFoundException('JSON schema not found at ' . $uri);
+        }
+
+        $this->messageBody = $response;
+        if (!empty($http_response_header)) {
+            // $http_response_header cannot be tested, because it's defined in the method's local scope
+            // See http://php.net/manual/en/reserved.variables.httpresponseheader.php for more info.
+            $this->fetchContentType($http_response_header); // @codeCoverageIgnore
+        } else {                                            // @codeCoverageIgnore
+            // Could be a "file://" url or something else - fake up the response
+            $this->contentType = null;
+        }
+
+        return $this->messageBody;
+    }
+
+    /**
+     * @param array $headers HTTP Response Headers
+     *
+     * @return bool Whether the Content-Type header was found or not
+     */
+    private function fetchContentType(array $headers)
+    {
+        foreach ($headers as $header) {
+            if ($this->contentType = self::getContentTypeMatchInHeader($header)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * @param string $header
+     *
+     * @return string|null
+     */
+    protected static function getContentTypeMatchInHeader($header)
+    {
+        if (0 < preg_match("/Content-Type:(\V*)/ims", $header, $match)) {
+            return trim($match[1]);
+        }
+
+        return null;
+    }
+}