dependabot-composer 0.107.27 → 0.107.28

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

@@ -0,0 +1,65 @@
+<?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\Constraints;
+
+use JsonSchema\Entity\JsonPointer;
+
+/**
+ * The Constraints Interface
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ */
+interface ConstraintInterface
+{
+    /**
+     * returns all collected errors
+     *
+     * @return array
+     */
+    public function getErrors();
+
+    /**
+     * adds errors to this validator
+     *
+     * @param array $errors
+     */
+    public function addErrors(array $errors);
+
+    /**
+     * adds an error
+     *
+     * @param JsonPointer|null $path
+     * @param string           $message
+     * @param string           $constraint the constraint/rule that is broken, e.g.: 'minLength'
+     * @param array            $more       more array elements to add to the error
+     */
+    public function addError(JsonPointer $path = null, $message, $constraint='', array $more = null);
+
+    /**
+     * checks if the validator has not raised errors
+     *
+     * @return bool
+     */
+    public function isValid();
+
+    /**
+     * invokes the validation of an element
+     *
+     * @abstract
+     *
+     * @param mixed            $value
+     * @param mixed            $schema
+     * @param JsonPointer|null $path
+     * @param mixed            $i
+     *
+     * @throws \JsonSchema\Exception\ExceptionInterface
+     */
+    public function check(&$value, $schema = null, JsonPointer $path = null, $i = null);
+}

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

@@ -0,0 +1,54 @@
+<?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\Constraints;
+
+use JsonSchema\Entity\JsonPointer;
+
+/**
+ * The EnumConstraint Constraints, validates an element against a given set of possibilities
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
+ */
+class EnumConstraint extends Constraint
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        // Only validate enum if the attribute exists
+        if ($element instanceof UndefinedConstraint && (!isset($schema->required) || !$schema->required)) {
+            return;
+        }
+        $type = gettype($element);
+
+        foreach ($schema->enum as $enum) {
+            $enumType = gettype($enum);
+            if ($this->factory->getConfig(self::CHECK_MODE_TYPE_CAST) && $type == 'array' && $enumType == 'object') {
+                if ((object) $element == $enum) {
+                    return;
+                }
+            }
+
+            if ($type === gettype($enum)) {
+                if ($type == 'object') {
+                    if ($element == $enum) {
+                        return;
+                    }
+                } elseif ($element === $enum) {
+                    return;
+                }
+            }
+        }
+
+        $this->addError($path, 'Does not have a value in the enumeration ' . json_encode($schema->enum), 'enum', array('enum' => $schema->enum));
+    }
+}

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

@@ -0,0 +1,220 @@
+<?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\Constraints;
+
+use JsonSchema\Exception\InvalidArgumentException;
+use JsonSchema\SchemaStorage;
+use JsonSchema\SchemaStorageInterface;
+use JsonSchema\Uri\UriRetriever;
+use JsonSchema\UriRetrieverInterface;
+use JsonSchema\Validator;
+
+/**
+ * Factory for centralize constraint initialization.
+ */
+class Factory
+{
+    /**
+     * @var SchemaStorage
+     */
+    protected $schemaStorage;
+
+    /**
+     * @var UriRetriever
+     */
+    protected $uriRetriever;
+
+    /**
+     * @var int
+     */
+    private $checkMode = Constraint::CHECK_MODE_NORMAL;
+
+    /**
+     * @var TypeCheck\TypeCheckInterface[]
+     */
+    private $typeCheck = array();
+
+    /**
+     * @var int Validation context
+     */
+    protected $errorContext = Validator::ERROR_DOCUMENT_VALIDATION;
+
+    /**
+     * @var array
+     */
+    protected $constraintMap = array(
+        'array' => 'JsonSchema\Constraints\CollectionConstraint',
+        'collection' => 'JsonSchema\Constraints\CollectionConstraint',
+        'object' => 'JsonSchema\Constraints\ObjectConstraint',
+        'type' => 'JsonSchema\Constraints\TypeConstraint',
+        'undefined' => 'JsonSchema\Constraints\UndefinedConstraint',
+        'string' => 'JsonSchema\Constraints\StringConstraint',
+        'number' => 'JsonSchema\Constraints\NumberConstraint',
+        'enum' => 'JsonSchema\Constraints\EnumConstraint',
+        'format' => 'JsonSchema\Constraints\FormatConstraint',
+        'schema' => 'JsonSchema\Constraints\SchemaConstraint',
+        'validator' => 'JsonSchema\Validator'
+    );
+
+    /**
+     * @var array<ConstraintInterface>
+     */
+    private $instanceCache = array();
+
+    /**
+     * @param SchemaStorage         $schemaStorage
+     * @param UriRetrieverInterface $uriRetriever
+     * @param int                   $checkMode
+     */
+    public function __construct(
+        SchemaStorageInterface $schemaStorage = null,
+        UriRetrieverInterface $uriRetriever = null,
+        $checkMode = Constraint::CHECK_MODE_NORMAL
+    ) {
+        // set provided config options
+        $this->setConfig($checkMode);
+
+        $this->uriRetriever = $uriRetriever ?: new UriRetriever();
+        $this->schemaStorage = $schemaStorage ?: new SchemaStorage($this->uriRetriever);
+    }
+
+    /**
+     * Set config values
+     *
+     * @param int $checkMode Set checkMode options - does not preserve existing flags
+     */
+    public function setConfig($checkMode = Constraint::CHECK_MODE_NORMAL)
+    {
+        $this->checkMode = $checkMode;
+    }
+
+    /**
+     * Enable checkMode flags
+     *
+     * @param int $options
+     */
+    public function addConfig($options)
+    {
+        $this->checkMode |= $options;
+    }
+
+    /**
+     * Disable checkMode flags
+     *
+     * @param int $options
+     */
+    public function removeConfig($options)
+    {
+        $this->checkMode &= ~$options;
+    }
+
+    /**
+     * Get checkMode option
+     *
+     * @param int $options Options to get, if null then return entire bitmask
+     *
+     * @return int
+     */
+    public function getConfig($options = null)
+    {
+        if ($options === null) {
+            return $this->checkMode;
+        }
+
+        return $this->checkMode & $options;
+    }
+
+    /**
+     * @return UriRetrieverInterface
+     */
+    public function getUriRetriever()
+    {
+        return $this->uriRetriever;
+    }
+
+    public function getSchemaStorage()
+    {
+        return $this->schemaStorage;
+    }
+
+    public function getTypeCheck()
+    {
+        if (!isset($this->typeCheck[$this->checkMode])) {
+            $this->typeCheck[$this->checkMode] = ($this->checkMode & Constraint::CHECK_MODE_TYPE_CAST)
+                ? new TypeCheck\LooseTypeCheck()
+                : new TypeCheck\StrictTypeCheck();
+        }
+
+        return $this->typeCheck[$this->checkMode];
+    }
+
+    /**
+     * @param string $name
+     * @param string $class
+     *
+     * @return Factory
+     */
+    public function setConstraintClass($name, $class)
+    {
+        // Ensure class exists
+        if (!class_exists($class)) {
+            throw new InvalidArgumentException('Unknown constraint ' . $name);
+        }
+        // Ensure class is appropriate
+        if (!in_array('JsonSchema\Constraints\ConstraintInterface', class_implements($class))) {
+            throw new InvalidArgumentException('Invalid class ' . $name);
+        }
+        $this->constraintMap[$name] = $class;
+
+        return $this;
+    }
+
+    /**
+     * Create a constraint instance for the given constraint name.
+     *
+     * @param string $constraintName
+     *
+     * @throws InvalidArgumentException if is not possible create the constraint instance
+     *
+     * @return ConstraintInterface|ObjectConstraint
+     */
+    public function createInstanceFor($constraintName)
+    {
+        if (!isset($this->constraintMap[$constraintName])) {
+            throw new InvalidArgumentException('Unknown constraint ' . $constraintName);
+        }
+
+        if (!isset($this->instanceCache[$constraintName])) {
+            $this->instanceCache[$constraintName] = new $this->constraintMap[$constraintName]($this);
+        }
+
+        return clone $this->instanceCache[$constraintName];
+    }
+
+    /**
+     * Get the error context
+     *
+     * @return string
+     */
+    public function getErrorContext()
+    {
+        return $this->errorContext;
+    }
+
+    /**
+     * Set the error context
+     *
+     * @param string $validationContext
+     */
+    public function setErrorContext($errorContext)
+    {
+        $this->errorContext = $errorContext;
+    }
+}

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

@@ -0,0 +1,214 @@
+<?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\Constraints;
+
+use JsonSchema\Entity\JsonPointer;
+use JsonSchema\Rfc3339;
+
+/**
+ * Validates against the "format" property
+ *
+ * @author Justin Rainbow <justin.rainbow@gmail.com>
+ *
+ * @see   http://tools.ietf.org/html/draft-zyp-json-schema-03#section-5.23
+ */
+class FormatConstraint extends Constraint
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        if (!isset($schema->format) || $this->factory->getConfig(self::CHECK_MODE_DISABLE_FORMAT)) {
+            return;
+        }
+
+        switch ($schema->format) {
+            case 'date':
+                if (!$date = $this->validateDateTime($element, 'Y-m-d')) {
+                    $this->addError($path, sprintf('Invalid date %s, expected format YYYY-MM-DD', json_encode($element)), 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'time':
+                if (!$this->validateDateTime($element, 'H:i:s')) {
+                    $this->addError($path, sprintf('Invalid time %s, expected format hh:mm:ss', json_encode($element)), 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'date-time':
+                if (null === Rfc3339::createFromString($element)) {
+                    $this->addError($path, sprintf('Invalid date-time %s, expected format YYYY-MM-DDThh:mm:ssZ or YYYY-MM-DDThh:mm:ss+hh:mm', json_encode($element)), 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'utc-millisec':
+                if (!$this->validateDateTime($element, 'U')) {
+                    $this->addError($path, sprintf('Invalid time %s, expected integer of milliseconds since Epoch', json_encode($element)), 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'regex':
+                if (!$this->validateRegex($element)) {
+                    $this->addError($path, 'Invalid regex format ' . $element, 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'color':
+                if (!$this->validateColor($element)) {
+                    $this->addError($path, 'Invalid color', 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'style':
+                if (!$this->validateStyle($element)) {
+                    $this->addError($path, 'Invalid style', 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'phone':
+                if (!$this->validatePhone($element)) {
+                    $this->addError($path, 'Invalid phone number', 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'uri':
+                if (null === filter_var($element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE)) {
+                    $this->addError($path, 'Invalid URL format', 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'uriref':
+            case 'uri-reference':
+                if (null === filter_var($element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE)) {
+                    // FILTER_VALIDATE_URL does not conform to RFC-3986, and cannot handle relative URLs, but
+                    // the json-schema spec uses RFC-3986, so need a bit of hackery to properly validate them.
+                    // See https://tools.ietf.org/html/rfc3986#section-4.2 for additional information.
+                    if (substr($element, 0, 2) === '//') { // network-path reference
+                        $validURL = filter_var('scheme:' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
+                    } elseif (substr($element, 0, 1) === '/') { // absolute-path reference
+                        $validURL = filter_var('scheme://host' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
+                    } elseif (strlen($element)) { // relative-path reference
+                        $pathParts = explode('/', $element, 2);
+                        if (strpos($pathParts[0], ':') !== false) {
+                            $validURL = null;
+                        } else {
+                            $validURL = filter_var('scheme://host/' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
+                        }
+                    } else {
+                        $validURL = null;
+                    }
+                    if ($validURL === null) {
+                        $this->addError($path, 'Invalid URL format', 'format', array('format' => $schema->format));
+                    }
+                }
+                break;
+
+            case 'email':
+                $filterFlags = FILTER_NULL_ON_FAILURE;
+                if (defined('FILTER_FLAG_EMAIL_UNICODE')) {
+                    // Only available from PHP >= 7.1.0, so ignore it for coverage checks
+                    $filterFlags |= constant('FILTER_FLAG_EMAIL_UNICODE'); // @codeCoverageIgnore
+                }
+                if (null === filter_var($element, FILTER_VALIDATE_EMAIL, $filterFlags)) {
+                    $this->addError($path, 'Invalid email', 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'ip-address':
+            case 'ipv4':
+                if (null === filter_var($element, FILTER_VALIDATE_IP, FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4)) {
+                    $this->addError($path, 'Invalid IP address', 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'ipv6':
+                if (null === filter_var($element, FILTER_VALIDATE_IP, FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV6)) {
+                    $this->addError($path, 'Invalid IP address', 'format', array('format' => $schema->format));
+                }
+                break;
+
+            case 'host-name':
+            case 'hostname':
+                if (!$this->validateHostname($element)) {
+                    $this->addError($path, 'Invalid hostname', 'format', array('format' => $schema->format));
+                }
+                break;
+
+            default:
+                // Empty as it should be:
+                // The value of this keyword is called a format attribute. It MUST be a string.
+                // A format attribute can generally only validate a given set of instance types.
+                // If the type of the instance to validate is not in this set, validation for
+                // this format attribute and instance SHOULD succeed.
+                // http://json-schema.org/latest/json-schema-validation.html#anchor105
+                break;
+        }
+    }
+
+    protected function validateDateTime($datetime, $format)
+    {
+        $dt = \DateTime::createFromFormat($format, $datetime);
+
+        if (!$dt) {
+            return false;
+        }
+
+        if ($datetime === $dt->format($format)) {
+            return true;
+        }
+
+        // handles the case where a non-6 digit microsecond datetime is passed
+        // which will fail the above string comparison because the passed
+        // $datetime may be '2000-05-01T12:12:12.123Z' but format() will return
+        // '2000-05-01T12:12:12.123000Z'
+        if ((strpos('u', $format) !== -1) && (preg_match('/\.\d+Z$/', $datetime))) {
+            return true;
+        }
+
+        return false;
+    }
+
+    protected function validateRegex($regex)
+    {
+        return false !== @preg_match('/' . $regex . '/u', '');
+    }
+
+    protected function validateColor($color)
+    {
+        if (in_array(strtolower($color), array('aqua', 'black', 'blue', 'fuchsia',
+            'gray', 'green', 'lime', 'maroon', 'navy', 'olive', 'orange', 'purple',
+            'red', 'silver', 'teal', 'white', 'yellow'))) {
+            return true;
+        }
+
+        return preg_match('/^#([a-f0-9]{3}|[a-f0-9]{6})$/i', $color);
+    }
+
+    protected function validateStyle($style)
+    {
+        $properties     = explode(';', rtrim($style, ';'));
+        $invalidEntries = preg_grep('/^\s*[-a-z]+\s*:\s*.+$/i', $properties, PREG_GREP_INVERT);
+
+        return empty($invalidEntries);
+    }
+
+    protected function validatePhone($phone)
+    {
+        return preg_match('/^\+?(\(\d{3}\)|\d{3}) \d{3} \d{4}$/', $phone);
+    }
+
+    protected function validateHostname($host)
+    {
+        $hostnameRegex = '/^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/i';
+
+        return preg_match($hostnameRegex, $host);
+    }
+}