dependabot-composer 0.95.59 → 0.95.60

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

@@ -0,0 +1,148 @@
+<?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\Exception\InvalidArgumentException;
+use JsonSchema\Exception\ValidationException;
+use JsonSchema\Validator;
+
+/**
+ * A more basic constraint definition - used for the public
+ * interface to avoid exposing library internals.
+ */
+class BaseConstraint
+{
+    /**
+     * @var array Errors
+     */
+    protected $errors = array();
+
+    /**
+     * @var int All error types which have occurred
+     */
+    protected $errorMask = Validator::ERROR_NONE;
+
+    /**
+     * @var Factory
+     */
+    protected $factory;
+
+    /**
+     * @param Factory $factory
+     */
+    public function __construct(Factory $factory = null)
+    {
+        $this->factory = $factory ?: new Factory();
+    }
+
+    public function addError(JsonPointer $path = null, $message, $constraint = '', array $more = null)
+    {
+        $error = array(
+            'property' => $this->convertJsonPointerIntoPropertyPath($path ?: new JsonPointer('')),
+            'pointer' => ltrim(strval($path ?: new JsonPointer('')), '#'),
+            'message' => $message,
+            'constraint' => $constraint,
+            'context' => $this->factory->getErrorContext(),
+        );
+
+        if ($this->factory->getConfig(Constraint::CHECK_MODE_EXCEPTIONS)) {
+            throw new ValidationException(sprintf('Error validating %s: %s', $error['pointer'], $error['message']));
+        }
+
+        if (is_array($more) && count($more) > 0) {
+            $error += $more;
+        }
+
+        $this->errors[] = $error;
+        $this->errorMask |= $error['context'];
+    }
+
+    public function addErrors(array $errors)
+    {
+        if ($errors) {
+            $this->errors = array_merge($this->errors, $errors);
+            $errorMask = &$this->errorMask;
+            array_walk($errors, function ($error) use (&$errorMask) {
+                if (isset($error['context'])) {
+                    $errorMask |= $error['context'];
+                }
+            });
+        }
+    }
+
+    public function getErrors($errorContext = Validator::ERROR_ALL)
+    {
+        if ($errorContext === Validator::ERROR_ALL) {
+            return $this->errors;
+        }
+
+        return array_filter($this->errors, function ($error) use ($errorContext) {
+            if ($errorContext & $error['context']) {
+                return true;
+            }
+        });
+    }
+
+    public function numErrors($errorContext = Validator::ERROR_ALL)
+    {
+        if ($errorContext === Validator::ERROR_ALL) {
+            return count($this->errors);
+        }
+
+        return count($this->getErrors($errorContext));
+    }
+
+    public function isValid()
+    {
+        return !$this->getErrors();
+    }
+
+    /**
+     * Clears any reported errors.  Should be used between
+     * multiple validation checks.
+     */
+    public function reset()
+    {
+        $this->errors = array();
+        $this->errorMask = Validator::ERROR_NONE;
+    }
+
+    /**
+     * Get the error mask
+     *
+     * @return int
+     */
+    public function getErrorMask()
+    {
+        return $this->errorMask;
+    }
+
+    /**
+     * Recursively cast an associative array to an object
+     *
+     * @param array $array
+     *
+     * @return object
+     */
+    public static function arrayToObjectRecursive($array)
+    {
+        $json = json_encode($array);
+        if (json_last_error() !== \JSON_ERROR_NONE) {
+            $message = 'Unable to encode schema array as JSON';
+            if (function_exists('json_last_error_msg')) {
+                $message .= ': ' . json_last_error_msg();
+            }
+            throw new InvalidArgumentException($message);
+        }
+
+        return (object) json_decode($json);
+    }
+}

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

@@ -0,0 +1,147 @@
+<?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 CollectionConstraint Constraints, validates an array against a given schema
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
+ */
+class CollectionConstraint extends Constraint
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function check(&$value, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        // Verify minItems
+        if (isset($schema->minItems) && count($value) < $schema->minItems) {
+            $this->addError($path, 'There must be a minimum of ' . $schema->minItems . ' items in the array', 'minItems', array('minItems' => $schema->minItems));
+        }
+
+        // Verify maxItems
+        if (isset($schema->maxItems) && count($value) > $schema->maxItems) {
+            $this->addError($path, 'There must be a maximum of ' . $schema->maxItems . ' items in the array', 'maxItems', array('maxItems' => $schema->maxItems));
+        }
+
+        // Verify uniqueItems
+        if (isset($schema->uniqueItems) && $schema->uniqueItems) {
+            $unique = $value;
+            if (is_array($value) && count($value)) {
+                $unique = array_map(function ($e) {
+                    return var_export($e, true);
+                }, $value);
+            }
+            if (count(array_unique($unique)) != count($value)) {
+                $this->addError($path, 'There are no duplicates allowed in the array', 'uniqueItems');
+            }
+        }
+
+        // Verify items
+        if (isset($schema->items)) {
+            $this->validateItems($value, $schema, $path, $i);
+        }
+    }
+
+    /**
+     * Validates the items
+     *
+     * @param array            $value
+     * @param \stdClass        $schema
+     * @param JsonPointer|null $path
+     * @param string           $i
+     */
+    protected function validateItems(&$value, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        if (is_object($schema->items)) {
+            // just one type definition for the whole array
+
+            if (isset($schema->items->type)
+                && (
+                    $schema->items->type == 'string'
+                    || $schema->items->type == 'number'
+                    || $schema->items->type == 'integer'
+                )
+                && !isset($schema->additionalItems)
+            ) {
+                // performance optimization
+                $type = $schema->items->type;
+                $typeValidator = $this->factory->createInstanceFor('type');
+                $validator = $this->factory->createInstanceFor($type === 'integer' ? 'number' : $type);
+
+                foreach ($value as $k => &$v) {
+                    $k_path = $this->incrementPath($path, $k);
+                    $typeValidator->check($v, $schema->items, $k_path, $i);
+
+                    $validator->check($v, $schema->items, $k_path, $i);
+                }
+                unset($v); /* remove dangling reference to prevent any future bugs
+                            * caused by accidentally using $v elsewhere */
+                $this->addErrors($typeValidator->getErrors());
+                $this->addErrors($validator->getErrors());
+            } else {
+                foreach ($value as $k => &$v) {
+                    $initErrors = $this->getErrors();
+
+                    // First check if its defined in "items"
+                    $this->checkUndefined($v, $schema->items, $path, $k);
+
+                    // Recheck with "additionalItems" if the first test fails
+                    if (count($initErrors) < count($this->getErrors()) && (isset($schema->additionalItems) && $schema->additionalItems !== false)) {
+                        $secondErrors = $this->getErrors();
+                        $this->checkUndefined($v, $schema->additionalItems, $path, $k);
+                    }
+
+                    // Reset errors if needed
+                    if (isset($secondErrors) && count($secondErrors) < count($this->getErrors())) {
+                        $this->errors = $secondErrors;
+                    } elseif (isset($secondErrors) && count($secondErrors) === count($this->getErrors())) {
+                        $this->errors = $initErrors;
+                    }
+                }
+                unset($v); /* remove dangling reference to prevent any future bugs
+                            * caused by accidentally using $v elsewhere */
+            }
+        } else {
+            // Defined item type definitions
+            foreach ($value as $k => &$v) {
+                if (array_key_exists($k, $schema->items)) {
+                    $this->checkUndefined($v, $schema->items[$k], $path, $k);
+                } else {
+                    // Additional items
+                    if (property_exists($schema, 'additionalItems')) {
+                        if ($schema->additionalItems !== false) {
+                            $this->checkUndefined($v, $schema->additionalItems, $path, $k);
+                        } else {
+                            $this->addError(
+                                $path, 'The item ' . $i . '[' . $k . '] is not defined and the definition does not allow additional items', 'additionalItems', array('additionalItems' => $schema->additionalItems));
+                        }
+                    } else {
+                        // Should be valid against an empty schema
+                        $this->checkUndefined($v, new \stdClass(), $path, $k);
+                    }
+                }
+            }
+            unset($v); /* remove dangling reference to prevent any future bugs
+                        * caused by accidentally using $v elsewhere */
+
+            // Treat when we have more schema definitions than values, not for empty arrays
+            if (count($value) > 0) {
+                for ($k = count($value); $k < count($schema->items); $k++) {
+                    $undefinedInstance = $this->factory->createInstanceFor('undefined');
+                    $this->checkUndefined($undefinedInstance, $schema->items[$k], $path, $k);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,213 @@
+<?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 Base Constraints, all Validators should extend this class
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
+ */
+abstract class Constraint extends BaseConstraint implements ConstraintInterface
+{
+    protected $inlineSchemaProperty = '$schema';
+
+    const CHECK_MODE_NONE =             0x00000000;
+    const CHECK_MODE_NORMAL =           0x00000001;
+    const CHECK_MODE_TYPE_CAST =        0x00000002;
+    const CHECK_MODE_COERCE_TYPES =     0x00000004;
+    const CHECK_MODE_APPLY_DEFAULTS =   0x00000008;
+    const CHECK_MODE_EXCEPTIONS =       0x00000010;
+    const CHECK_MODE_DISABLE_FORMAT =   0x00000020;
+    const CHECK_MODE_ONLY_REQUIRED_DEFAULTS   = 0x00000080;
+    const CHECK_MODE_VALIDATE_SCHEMA =  0x00000100;
+
+    /**
+     * Bubble down the path
+     *
+     * @param JsonPointer|null $path Current path
+     * @param mixed            $i    What to append to the path
+     *
+     * @return JsonPointer;
+     */
+    protected function incrementPath(JsonPointer $path = null, $i)
+    {
+        $path = $path ?: new JsonPointer('');
+        $path = $path->withPropertyPaths(
+            array_merge(
+                $path->getPropertyPaths(),
+                array_filter(array($i), 'strlen')
+            )
+        );
+
+        return $path;
+    }
+
+    /**
+     * Validates an array
+     *
+     * @param mixed            $value
+     * @param mixed            $schema
+     * @param JsonPointer|null $path
+     * @param mixed            $i
+     */
+    protected function checkArray(&$value, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        $validator = $this->factory->createInstanceFor('collection');
+        $validator->check($value, $schema, $path, $i);
+
+        $this->addErrors($validator->getErrors());
+    }
+
+    /**
+     * Validates an object
+     *
+     * @param mixed            $value
+     * @param mixed            $schema
+     * @param JsonPointer|null $path
+     * @param mixed            $properties
+     * @param mixed            $additionalProperties
+     * @param mixed            $patternProperties
+     */
+    protected function checkObject(&$value, $schema = null, JsonPointer $path = null, $properties = null,
+        $additionalProperties = null, $patternProperties = null, $appliedDefaults = array())
+    {
+        $validator = $this->factory->createInstanceFor('object');
+        $validator->check($value, $schema, $path, $properties, $additionalProperties, $patternProperties, $appliedDefaults);
+
+        $this->addErrors($validator->getErrors());
+    }
+
+    /**
+     * Validates the type of a property
+     *
+     * @param mixed            $value
+     * @param mixed            $schema
+     * @param JsonPointer|null $path
+     * @param mixed            $i
+     */
+    protected function checkType(&$value, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        $validator = $this->factory->createInstanceFor('type');
+        $validator->check($value, $schema, $path, $i);
+
+        $this->addErrors($validator->getErrors());
+    }
+
+    /**
+     * Checks a undefined element
+     *
+     * @param mixed            $value
+     * @param mixed            $schema
+     * @param JsonPointer|null $path
+     * @param mixed            $i
+     */
+    protected function checkUndefined(&$value, $schema = null, JsonPointer $path = null, $i = null, $fromDefault = false)
+    {
+        $validator = $this->factory->createInstanceFor('undefined');
+
+        $validator->check($value, $this->factory->getSchemaStorage()->resolveRefSchema($schema), $path, $i, $fromDefault);
+
+        $this->addErrors($validator->getErrors());
+    }
+
+    /**
+     * Checks a string element
+     *
+     * @param mixed            $value
+     * @param mixed            $schema
+     * @param JsonPointer|null $path
+     * @param mixed            $i
+     */
+    protected function checkString($value, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        $validator = $this->factory->createInstanceFor('string');
+        $validator->check($value, $schema, $path, $i);
+
+        $this->addErrors($validator->getErrors());
+    }
+
+    /**
+     * Checks a number element
+     *
+     * @param mixed       $value
+     * @param mixed       $schema
+     * @param JsonPointer $path
+     * @param mixed       $i
+     */
+    protected function checkNumber($value, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        $validator = $this->factory->createInstanceFor('number');
+        $validator->check($value, $schema, $path, $i);
+
+        $this->addErrors($validator->getErrors());
+    }
+
+    /**
+     * Checks a enum element
+     *
+     * @param mixed            $value
+     * @param mixed            $schema
+     * @param JsonPointer|null $path
+     * @param mixed            $i
+     */
+    protected function checkEnum($value, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        $validator = $this->factory->createInstanceFor('enum');
+        $validator->check($value, $schema, $path, $i);
+
+        $this->addErrors($validator->getErrors());
+    }
+
+    /**
+     * Checks format of an element
+     *
+     * @param mixed            $value
+     * @param mixed            $schema
+     * @param JsonPointer|null $path
+     * @param mixed            $i
+     */
+    protected function checkFormat($value, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        $validator = $this->factory->createInstanceFor('format');
+        $validator->check($value, $schema, $path, $i);
+
+        $this->addErrors($validator->getErrors());
+    }
+
+    /**
+     * Get the type check based on the set check mode.
+     *
+     * @return TypeCheck\TypeCheckInterface
+     */
+    protected function getTypeCheck()
+    {
+        return $this->factory->getTypeCheck();
+    }
+
+    /**
+     * @param JsonPointer $pointer
+     *
+     * @return string property path
+     */
+    protected function convertJsonPointerIntoPropertyPath(JsonPointer $pointer)
+    {
+        $result = array_map(
+            function ($path) {
+                return sprintf(is_numeric($path) ? '[%d]' : '.%s', $path);
+            },
+            $pointer->getPropertyPaths()
+        );
+
+        return trim(implode('', $result), '.');
+    }
+}