dependabot-composer 0.111.24 → 0.111.25

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

@@ -0,0 +1,81 @@
+<?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 NumberConstraint Constraints, validates an number against a given schema
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
+ */
+class NumberConstraint extends Constraint
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        // Verify minimum
+        if (isset($schema->exclusiveMinimum)) {
+            if (isset($schema->minimum)) {
+                if ($schema->exclusiveMinimum && $element <= $schema->minimum) {
+                    $this->addError($path, 'Must have a minimum value of ' . $schema->minimum, 'exclusiveMinimum', array('minimum' => $schema->minimum));
+                } elseif ($element < $schema->minimum) {
+                    $this->addError($path, 'Must have a minimum value of ' . $schema->minimum, 'minimum', array('minimum' => $schema->minimum));
+                }
+            } else {
+                $this->addError($path, 'Use of exclusiveMinimum requires presence of minimum', 'missingMinimum');
+            }
+        } elseif (isset($schema->minimum) && $element < $schema->minimum) {
+            $this->addError($path, 'Must have a minimum value of ' . $schema->minimum, 'minimum', array('minimum' => $schema->minimum));
+        }
+
+        // Verify maximum
+        if (isset($schema->exclusiveMaximum)) {
+            if (isset($schema->maximum)) {
+                if ($schema->exclusiveMaximum && $element >= $schema->maximum) {
+                    $this->addError($path, 'Must have a maximum value of ' . $schema->maximum, 'exclusiveMaximum', array('maximum' => $schema->maximum));
+                } elseif ($element > $schema->maximum) {
+                    $this->addError($path, 'Must have a maximum value of ' . $schema->maximum, 'maximum', array('maximum' => $schema->maximum));
+                }
+            } else {
+                $this->addError($path, 'Use of exclusiveMaximum requires presence of maximum', 'missingMaximum');
+            }
+        } elseif (isset($schema->maximum) && $element > $schema->maximum) {
+            $this->addError($path, 'Must have a maximum value of ' . $schema->maximum, 'maximum', array('maximum' => $schema->maximum));
+        }
+
+        // Verify divisibleBy - Draft v3
+        if (isset($schema->divisibleBy) && $this->fmod($element, $schema->divisibleBy) != 0) {
+            $this->addError($path, 'Is not divisible by ' . $schema->divisibleBy, 'divisibleBy', array('divisibleBy' => $schema->divisibleBy));
+        }
+
+        // Verify multipleOf - Draft v4
+        if (isset($schema->multipleOf) && $this->fmod($element, $schema->multipleOf) != 0) {
+            $this->addError($path, 'Must be a multiple of ' . $schema->multipleOf, 'multipleOf', array('multipleOf' => $schema->multipleOf));
+        }
+
+        $this->checkFormat($element, $schema, $path, $i);
+    }
+
+    private function fmod($number1, $number2)
+    {
+        $modulus = ($number1 - round($number1 / $number2) * $number2);
+        $precision = 0.0000000001;
+
+        if (-$precision < $modulus && $modulus < $precision) {
+            return 0.0;
+        }
+
+        return $modulus;
+    }
+}

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

@@ -0,0 +1,192 @@
+<?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 ObjectConstraint Constraints, validates an object against a given schema
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
+ */
+class ObjectConstraint extends Constraint
+{
+    /**
+     * @var array List of properties to which a default value has been applied
+     */
+    protected $appliedDefaults = array();
+
+    /**
+     * {@inheritdoc}
+     */
+    public function check(&$element, $schema = null, JsonPointer $path = null, $properties = null,
+        $additionalProp = null, $patternProperties = null, $appliedDefaults = array())
+    {
+        if ($element instanceof UndefinedConstraint) {
+            return;
+        }
+
+        $this->appliedDefaults = $appliedDefaults;
+
+        $matches = array();
+        if ($patternProperties) {
+            // validate the element pattern properties
+            $matches = $this->validatePatternProperties($element, $path, $patternProperties);
+        }
+
+        if ($properties) {
+            // validate the element properties
+            $this->validateProperties($element, $properties, $path);
+        }
+
+        // validate additional element properties & constraints
+        $this->validateElement($element, $matches, $schema, $path, $properties, $additionalProp);
+    }
+
+    public function validatePatternProperties($element, JsonPointer $path = null, $patternProperties)
+    {
+        $try = array('/', '#', '+', '~', '%');
+        $matches = array();
+        foreach ($patternProperties as $pregex => $schema) {
+            $delimiter = '/';
+            // Choose delimiter. Necessary for patterns like ^/ , otherwise you get error
+            foreach ($try as $delimiter) {
+                if (strpos($pregex, $delimiter) === false) { // safe to use
+                    break;
+                }
+            }
+
+            // Validate the pattern before using it to test for matches
+            if (@preg_match($delimiter . $pregex . $delimiter . 'u', '') === false) {
+                $this->addError($path, 'The pattern "' . $pregex . '" is invalid', 'pregex', array('pregex' => $pregex));
+                continue;
+            }
+            foreach ($element as $i => $value) {
+                if (preg_match($delimiter . $pregex . $delimiter . 'u', $i)) {
+                    $matches[] = $i;
+                    $this->checkUndefined($value, $schema ?: new \stdClass(), $path, $i, in_array($i, $this->appliedDefaults));
+                }
+            }
+        }
+
+        return $matches;
+    }
+
+    /**
+     * Validates the element properties
+     *
+     * @param \StdClass        $element        Element to validate
+     * @param array            $matches        Matches from patternProperties (if any)
+     * @param \StdClass        $schema         ObjectConstraint definition
+     * @param JsonPointer|null $path           Current test path
+     * @param \StdClass        $properties     Properties
+     * @param mixed            $additionalProp Additional properties
+     */
+    public function validateElement($element, $matches, $schema = null, JsonPointer $path = null,
+        $properties = null, $additionalProp = null)
+    {
+        $this->validateMinMaxConstraint($element, $schema, $path);
+
+        foreach ($element as $i => $value) {
+            $definition = $this->getProperty($properties, $i);
+
+            // no additional properties allowed
+            if (!in_array($i, $matches) && $additionalProp === false && $this->inlineSchemaProperty !== $i && !$definition) {
+                $this->addError($path, 'The property ' . $i . ' is not defined and the definition does not allow additional properties', 'additionalProp');
+            }
+
+            // additional properties defined
+            if (!in_array($i, $matches) && $additionalProp && !$definition) {
+                if ($additionalProp === true) {
+                    $this->checkUndefined($value, null, $path, $i, in_array($i, $this->appliedDefaults));
+                } else {
+                    $this->checkUndefined($value, $additionalProp, $path, $i, in_array($i, $this->appliedDefaults));
+                }
+            }
+
+            // property requires presence of another
+            $require = $this->getProperty($definition, 'requires');
+            if ($require && !$this->getProperty($element, $require)) {
+                $this->addError($path, 'The presence of the property ' . $i . ' requires that ' . $require . ' also be present', 'requires');
+            }
+
+            $property = $this->getProperty($element, $i, $this->factory->createInstanceFor('undefined'));
+            if (is_object($property)) {
+                $this->validateMinMaxConstraint(!($property instanceof UndefinedConstraint) ? $property : $element, $definition, $path);
+            }
+        }
+    }
+
+    /**
+     * Validates the definition properties
+     *
+     * @param \stdClass        $element    Element to validate
+     * @param \stdClass        $properties Property definitions
+     * @param JsonPointer|null $path       Path?
+     */
+    public function validateProperties(&$element, $properties = null, JsonPointer $path = null)
+    {
+        $undefinedConstraint = $this->factory->createInstanceFor('undefined');
+
+        foreach ($properties as $i => $value) {
+            $property = &$this->getProperty($element, $i, $undefinedConstraint);
+            $definition = $this->getProperty($properties, $i);
+
+            if (is_object($definition)) {
+                // Undefined constraint will check for is_object() and quit if is not - so why pass it?
+                $this->checkUndefined($property, $definition, $path, $i, in_array($i, $this->appliedDefaults));
+            }
+        }
+    }
+
+    /**
+     * retrieves a property from an object or array
+     *
+     * @param mixed  $element  Element to validate
+     * @param string $property Property to retrieve
+     * @param mixed  $fallback Default value if property is not found
+     *
+     * @return mixed
+     */
+    protected function &getProperty(&$element, $property, $fallback = null)
+    {
+        if (is_array($element) && (isset($element[$property]) || array_key_exists($property, $element)) /*$this->checkMode == self::CHECK_MODE_TYPE_CAST*/) {
+            return $element[$property];
+        } elseif (is_object($element) && property_exists($element, $property)) {
+            return $element->$property;
+        }
+
+        return $fallback;
+    }
+
+    /**
+     * validating minimum and maximum property constraints (if present) against an element
+     *
+     * @param \stdClass        $element          Element to validate
+     * @param \stdClass        $objectDefinition ObjectConstraint definition
+     * @param JsonPointer|null $path             Path to test?
+     */
+    protected function validateMinMaxConstraint($element, $objectDefinition, JsonPointer $path = null)
+    {
+        // Verify minimum number of properties
+        if (isset($objectDefinition->minProperties) && !is_object($objectDefinition->minProperties)) {
+            if ($this->getTypeCheck()->propertyCount($element) < $objectDefinition->minProperties) {
+                $this->addError($path, 'Must contain a minimum of ' . $objectDefinition->minProperties . ' properties', 'minProperties', array('minProperties' => $objectDefinition->minProperties));
+            }
+        }
+        // Verify maximum number of properties
+        if (isset($objectDefinition->maxProperties) && !is_object($objectDefinition->maxProperties)) {
+            if ($this->getTypeCheck()->propertyCount($element) > $objectDefinition->maxProperties) {
+                $this->addError($path, 'Must contain no more than ' . $objectDefinition->maxProperties . ' properties', 'maxProperties', array('maxProperties' => $objectDefinition->maxProperties));
+            }
+        }
+    }
+}

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

@@ -0,0 +1,94 @@
+<?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\InvalidSchemaException;
+use JsonSchema\Exception\RuntimeException;
+use JsonSchema\Validator;
+
+/**
+ * The SchemaConstraint Constraints, validates an element against a given schema
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
+ */
+class SchemaConstraint extends Constraint
+{
+    const DEFAULT_SCHEMA_SPEC = 'http://json-schema.org/draft-04/schema#';
+
+    /**
+     * {@inheritdoc}
+     */
+    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        if ($schema !== null) {
+            // passed schema
+            $validationSchema = $schema;
+        } elseif ($this->getTypeCheck()->propertyExists($element, $this->inlineSchemaProperty)) {
+            // inline schema
+            $validationSchema = $this->getTypeCheck()->propertyGet($element, $this->inlineSchemaProperty);
+        } else {
+            throw new InvalidArgumentException('no schema found to verify against');
+        }
+
+        // cast array schemas to object
+        if (is_array($validationSchema)) {
+            $validationSchema = BaseConstraint::arrayToObjectRecursive($validationSchema);
+        }
+
+        // validate schema against whatever is defined in $validationSchema->$schema. If no
+        // schema is defined, assume self::DEFAULT_SCHEMA_SPEC (currently draft-04).
+        if ($this->factory->getConfig(self::CHECK_MODE_VALIDATE_SCHEMA)) {
+            if (!$this->getTypeCheck()->isObject($validationSchema)) {
+                throw new RuntimeException('Cannot validate the schema of a non-object');
+            }
+            if ($this->getTypeCheck()->propertyExists($validationSchema, '$schema')) {
+                $schemaSpec = $this->getTypeCheck()->propertyGet($validationSchema, '$schema');
+            } else {
+                $schemaSpec = self::DEFAULT_SCHEMA_SPEC;
+            }
+
+            // get the spec schema
+            $schemaStorage = $this->factory->getSchemaStorage();
+            if (!$this->getTypeCheck()->isObject($schemaSpec)) {
+                $schemaSpec = $schemaStorage->getSchema($schemaSpec);
+            }
+
+            // save error count, config & subtract CHECK_MODE_VALIDATE_SCHEMA
+            $initialErrorCount = $this->numErrors();
+            $initialConfig = $this->factory->getConfig();
+            $initialContext = $this->factory->getErrorContext();
+            $this->factory->removeConfig(self::CHECK_MODE_VALIDATE_SCHEMA | self::CHECK_MODE_APPLY_DEFAULTS);
+            $this->factory->addConfig(self::CHECK_MODE_TYPE_CAST);
+            $this->factory->setErrorContext(Validator::ERROR_SCHEMA_VALIDATION);
+
+            // validate schema
+            try {
+                $this->check($validationSchema, $schemaSpec);
+            } catch (\Exception $e) {
+                if ($this->factory->getConfig(self::CHECK_MODE_EXCEPTIONS)) {
+                    throw new InvalidSchemaException('Schema did not pass validation', 0, $e);
+                }
+            }
+            if ($this->numErrors() > $initialErrorCount) {
+                $this->addError($path, 'Schema is not valid', 'schema');
+            }
+
+            // restore the initial config
+            $this->factory->setConfig($initialConfig);
+            $this->factory->setErrorContext($initialContext);
+        }
+
+        // validate element against $validationSchema
+        $this->checkUndefined($element, $validationSchema, $path, $i);
+    }
+}

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

@@ -0,0 +1,60 @@
+<?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 StringConstraint Constraints, validates an string against a given schema
+ *
+ * @author Robert Schönthal <seroscho@googlemail.com>
+ * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
+ */
+class StringConstraint extends Constraint
+{
+    /**
+     * {@inheritdoc}
+     */
+    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    {
+        // Verify maxLength
+        if (isset($schema->maxLength) && $this->strlen($element) > $schema->maxLength) {
+            $this->addError($path, 'Must be at most ' . $schema->maxLength . ' characters long', 'maxLength', array(
+                'maxLength' => $schema->maxLength,
+            ));
+        }
+
+        //verify minLength
+        if (isset($schema->minLength) && $this->strlen($element) < $schema->minLength) {
+            $this->addError($path, 'Must be at least ' . $schema->minLength . ' characters long', 'minLength', array(
+                'minLength' => $schema->minLength,
+            ));
+        }
+
+        // Verify a regex pattern
+        if (isset($schema->pattern) && !preg_match('#' . str_replace('#', '\\#', $schema->pattern) . '#u', $element)) {
+            $this->addError($path, 'Does not match the regex pattern ' . $schema->pattern, 'pattern', array(
+                'pattern' => $schema->pattern,
+            ));
+        }
+
+        $this->checkFormat($element, $schema, $path, $i);
+    }
+
+    private function strlen($string)
+    {
+        if (extension_loaded('mbstring')) {
+            return mb_strlen($string, mb_detect_encoding($string));
+        }
+
+        // mbstring is present on all test platforms, so strlen() can be ignored for coverage
+        return strlen($string); // @codeCoverageIgnore
+    }
+}

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

@@ -0,0 +1,68 @@
+<?php
+
+namespace JsonSchema\Constraints\TypeCheck;
+
+class LooseTypeCheck implements TypeCheckInterface
+{
+    public static function isObject($value)
+    {
+        return
+            is_object($value) ||
+            (is_array($value) && (count($value) == 0 || self::isAssociativeArray($value)));
+    }
+
+    public static function isArray($value)
+    {
+        return
+            is_array($value) &&
+            (count($value) == 0 || !self::isAssociativeArray($value));
+    }
+
+    public static function propertyGet($value, $property)
+    {
+        if (is_object($value)) {
+            return $value->{$property};
+        }
+
+        return $value[$property];
+    }
+
+    public static function propertySet(&$value, $property, $data)
+    {
+        if (is_object($value)) {
+            $value->{$property} = $data;
+        } else {
+            $value[$property] = $data;
+        }
+    }
+
+    public static function propertyExists($value, $property)
+    {
+        if (is_object($value)) {
+            return property_exists($value, $property);
+        }
+
+        return array_key_exists($property, $value);
+    }
+
+    public static function propertyCount($value)
+    {
+        if (is_object($value)) {
+            return count(get_object_vars($value));
+        }
+
+        return count($value);
+    }
+
+    /**
+     * Check if the provided array is associative or not
+     *
+     * @param array $arr
+     *
+     * @return bool
+     */
+    private static function isAssociativeArray($arr)
+    {
+        return array_keys($arr) !== range(0, count($arr) - 1);
+    }
+}