dependabot-composer 0.107.14 → 0.107.15

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

@@ -1,81 +0,0 @@
-<?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

@@ -1,192 +0,0 @@
-<?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

@@ -1,94 +0,0 @@
-<?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

@@ -1,60 +0,0 @@
-<?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

@@ -1,68 +0,0 @@
-<?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);
-    }
-}