dependabot-composer 0.119.0.beta1 → 0.119.0

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

@@ -1,40 +0,0 @@
-<?php
-
-namespace JsonSchema\Constraints\TypeCheck;
-
-class StrictTypeCheck implements TypeCheckInterface
-{
-    public static function isObject($value)
-    {
-        return is_object($value);
-    }
-
-    public static function isArray($value)
-    {
-        return is_array($value);
-    }
-
-    public static function propertyGet($value, $property)
-    {
-        return $value->{$property};
-    }
-
-    public static function propertySet(&$value, $property, $data)
-    {
-        $value->{$property} = $data;
-    }
-
-    public static function propertyExists($value, $property)
-    {
-        return property_exists($value, $property);
-    }
-
-    public static function propertyCount($value)
-    {
-        if (!is_object($value)) {
-            return 0;
-        }
-
-        return count(get_object_vars($value));
-    }
-}

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

@@ -1,18 +0,0 @@
-<?php
-
-namespace JsonSchema\Constraints\TypeCheck;
-
-interface TypeCheckInterface
-{
-    public static function isObject($value);
-
-    public static function isArray($value);
-
-    public static function propertyGet($value, $property);
-
-    public static function propertySet(&$value, $property, $data);
-
-    public static function propertyExists($value, $property);
-
-    public static function propertyCount($value);
-}

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

@@ -1,261 +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 UnexpectedValueException as StandardUnexpectedValueException;
-
-/**
- * The TypeConstraint Constraints, validates an element against a given type
- *
- * @author Robert Schönthal <seroscho@googlemail.com>
- * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
- */
-class TypeConstraint extends Constraint
-{
-    /**
-     * @var array|string[] type wordings for validation error messages
-     */
-    public static $wording = array(
-        'integer' => 'an integer',
-        'number'  => 'a number',
-        'boolean' => 'a boolean',
-        'object'  => 'an object',
-        'array'   => 'an array',
-        'string'  => 'a string',
-        'null'    => 'a null',
-        'any'     => null, // validation of 'any' is always true so is not needed in message wording
-        0         => null, // validation of a false-y value is always true, so not needed as well
-    );
-
-    /**
-     * {@inheritdoc}
-     */
-    public function check(&$value = null, $schema = null, JsonPointer $path = null, $i = null)
-    {
-        $type = isset($schema->type) ? $schema->type : null;
-        $isValid = false;
-        $wording = array();
-
-        if (is_array($type)) {
-            $this->validateTypesArray($value, $type, $wording, $isValid, $path);
-        } elseif (is_object($type)) {
-            $this->checkUndefined($value, $type, $path);
-
-            return;
-        } else {
-            $isValid = $this->validateType($value, $type);
-        }
-
-        if ($isValid === false) {
-            if (!is_array($type)) {
-                $this->validateTypeNameWording($type);
-                $wording[] = self::$wording[$type];
-            }
-            $this->addError($path, ucwords(gettype($value)) . ' value found, but ' .
-                $this->implodeWith($wording, ', ', 'or') . ' is required', 'type');
-        }
-    }
-
-    /**
-     * Validates the given $value against the array of types in $type. Sets the value
-     * of $isValid to true, if at least one $type mateches the type of $value or the value
-     * passed as $isValid is already true.
-     *
-     * @param mixed $value             Value to validate
-     * @param array $type              TypeConstraints to check agains
-     * @param array $validTypesWording An array of wordings of the valid types of the array $type
-     * @param bool  $isValid           The current validation value
-     * @param $path
-     */
-    protected function validateTypesArray(&$value, array $type, &$validTypesWording, &$isValid, $path)
-    {
-        foreach ($type as $tp) {
-            // $tp can be an object, if it's a schema instead of a simple type, validate it
-            // with a new type constraint
-            if (is_object($tp)) {
-                if (!$isValid) {
-                    $validator = $this->factory->createInstanceFor('type');
-                    $subSchema = new \stdClass();
-                    $subSchema->type = $tp;
-                    $validator->check($value, $subSchema, $path, null);
-                    $error = $validator->getErrors();
-                    $isValid = !(bool) $error;
-                    $validTypesWording[] = self::$wording['object'];
-                }
-            } else {
-                $this->validateTypeNameWording($tp);
-                $validTypesWording[] = self::$wording[$tp];
-                if (!$isValid) {
-                    $isValid = $this->validateType($value, $tp);
-                }
-            }
-        }
-    }
-
-    /**
-     * Implodes the given array like implode() with turned around parameters and with the
-     * difference, that, if $listEnd isn't false, the last element delimiter is $listEnd instead of
-     * $delimiter.
-     *
-     * @param array  $elements  The elements to implode
-     * @param string $delimiter The delimiter to use
-     * @param bool   $listEnd   The last delimiter to use (defaults to $delimiter)
-     *
-     * @return string
-     */
-    protected function implodeWith(array $elements, $delimiter = ', ', $listEnd = false)
-    {
-        if ($listEnd === false || !isset($elements[1])) {
-            return implode($delimiter, $elements);
-        }
-        $lastElement  = array_slice($elements, -1);
-        $firsElements = join($delimiter, array_slice($elements, 0, -1));
-        $implodedElements = array_merge(array($firsElements), $lastElement);
-
-        return join(" $listEnd ", $implodedElements);
-    }
-
-    /**
-     * Validates the given $type, if there's an associated self::$wording. If not, throws an
-     * exception.
-     *
-     * @param string $type The type to validate
-     *
-     * @throws StandardUnexpectedValueException
-     */
-    protected function validateTypeNameWording($type)
-    {
-        if (!isset(self::$wording[$type])) {
-            throw new StandardUnexpectedValueException(
-                sprintf(
-                    'No wording for %s available, expected wordings are: [%s]',
-                    var_export($type, true),
-                    implode(', ', array_filter(self::$wording)))
-            );
-        }
-    }
-
-    /**
-     * Verifies that a given value is of a certain type
-     *
-     * @param mixed  $value Value to validate
-     * @param string $type  TypeConstraint to check against
-     *
-     * @throws InvalidArgumentException
-     *
-     * @return bool
-     */
-    protected function validateType(&$value, $type)
-    {
-        //mostly the case for inline schema
-        if (!$type) {
-            return true;
-        }
-
-        if ('any' === $type) {
-            return true;
-        }
-
-        if ('object' === $type) {
-            return $this->getTypeCheck()->isObject($value);
-        }
-
-        if ('array' === $type) {
-            return $this->getTypeCheck()->isArray($value);
-        }
-
-        $coerce = $this->factory->getConfig(Constraint::CHECK_MODE_COERCE_TYPES);
-
-        if ('integer' === $type) {
-            if ($coerce) {
-                $value = $this->toInteger($value);
-            }
-
-            return is_int($value);
-        }
-
-        if ('number' === $type) {
-            if ($coerce) {
-                $value = $this->toNumber($value);
-            }
-
-            return is_numeric($value) && !is_string($value);
-        }
-
-        if ('boolean' === $type) {
-            if ($coerce) {
-                $value = $this->toBoolean($value);
-            }
-
-            return is_bool($value);
-        }
-
-        if ('string' === $type) {
-            return is_string($value);
-        }
-
-        if ('email' === $type) {
-            return is_string($value);
-        }
-
-        if ('null' === $type) {
-            return is_null($value);
-        }
-
-        throw new InvalidArgumentException((is_object($value) ? 'object' : $value) . ' is an invalid type for ' . $type);
-    }
-
-    /**
-     * Converts a value to boolean. For example, "true" becomes true.
-     *
-     * @param $value The value to convert to boolean
-     *
-     * @return bool|mixed
-     */
-    protected function toBoolean($value)
-    {
-        if ($value === 'true') {
-            return true;
-        }
-
-        if ($value === 'false') {
-            return false;
-        }
-
-        return $value;
-    }
-
-    /**
-     * Converts a numeric string to a number. For example, "4" becomes 4.
-     *
-     * @param mixed $value the value to convert to a number
-     *
-     * @return int|float|mixed
-     */
-    protected function toNumber($value)
-    {
-        if (is_numeric($value)) {
-            return $value + 0; // cast to number
-        }
-
-        return $value;
-    }
-
-    protected function toInteger($value)
-    {
-        if (is_numeric($value) && (int) $value == $value) {
-            return (int) $value; // cast to number
-        }
-
-        return $value;
-    }
-}

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

@@ -1,419 +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\Constraints\TypeCheck\LooseTypeCheck;
-use JsonSchema\Entity\JsonPointer;
-use JsonSchema\Exception\ValidationException;
-use JsonSchema\Uri\UriResolver;
-
-/**
- * The UndefinedConstraint Constraints
- *
- * @author Robert Schönthal <seroscho@googlemail.com>
- * @author Bruno Prieto Reis <bruno.p.reis@gmail.com>
- */
-class UndefinedConstraint extends Constraint
-{
-    /**
-     * @var array List of properties to which a default value has been applied
-     */
-    protected $appliedDefaults = array();
-
-    /**
-     * {@inheritdoc}
-     */
-    public function check(&$value, $schema = null, JsonPointer $path = null, $i = null, $fromDefault = false)
-    {
-        if (is_null($schema) || !is_object($schema)) {
-            return;
-        }
-
-        $path = $this->incrementPath($path ?: new JsonPointer(''), $i);
-        if ($fromDefault) {
-            $path->setFromDefault();
-        }
-
-        // check special properties
-        $this->validateCommonProperties($value, $schema, $path, $i);
-
-        // check allOf, anyOf, and oneOf properties
-        $this->validateOfProperties($value, $schema, $path, '');
-
-        // check known types
-        $this->validateTypes($value, $schema, $path, $i);
-    }
-
-    /**
-     * Validates the value against the types
-     *
-     * @param mixed       $value
-     * @param mixed       $schema
-     * @param JsonPointer $path
-     * @param string      $i
-     */
-    public function validateTypes(&$value, $schema, JsonPointer $path, $i = null)
-    {
-        // check array
-        if ($this->getTypeCheck()->isArray($value)) {
-            $this->checkArray($value, $schema, $path, $i);
-        }
-
-        // check object
-        if (LooseTypeCheck::isObject($value)) { // object processing should always be run on assoc arrays,
-                                                // so use LooseTypeCheck here even if CHECK_MODE_TYPE_CAST
-                                                // is not set (i.e. don't use $this->getTypeCheck() here).
-            $this->checkObject(
-                $value,
-                $schema,
-                $path,
-                isset($schema->properties) ? $schema->properties : null,
-                isset($schema->additionalProperties) ? $schema->additionalProperties : null,
-                isset($schema->patternProperties) ? $schema->patternProperties : null,
-                $this->appliedDefaults
-            );
-        }
-
-        // check string
-        if (is_string($value)) {
-            $this->checkString($value, $schema, $path, $i);
-        }
-
-        // check numeric
-        if (is_numeric($value)) {
-            $this->checkNumber($value, $schema, $path, $i);
-        }
-
-        // check enum
-        if (isset($schema->enum)) {
-            $this->checkEnum($value, $schema, $path, $i);
-        }
-    }
-
-    /**
-     * Validates common properties
-     *
-     * @param mixed       $value
-     * @param mixed       $schema
-     * @param JsonPointer $path
-     * @param string      $i
-     */
-    protected function validateCommonProperties(&$value, $schema, JsonPointer $path, $i = '')
-    {
-        // if it extends another schema, it must pass that schema as well
-        if (isset($schema->extends)) {
-            if (is_string($schema->extends)) {
-                $schema->extends = $this->validateUri($schema, $schema->extends);
-            }
-            if (is_array($schema->extends)) {
-                foreach ($schema->extends as $extends) {
-                    $this->checkUndefined($value, $extends, $path, $i);
-                }
-            } else {
-                $this->checkUndefined($value, $schema->extends, $path, $i);
-            }
-        }
-
-        // Apply default values from schema
-        if (!$path->fromDefault()) {
-            $this->applyDefaultValues($value, $schema, $path);
-        }
-
-        // Verify required values
-        if ($this->getTypeCheck()->isObject($value)) {
-            if (!($value instanceof self) && isset($schema->required) && is_array($schema->required)) {
-                // Draft 4 - Required is an array of strings - e.g. "required": ["foo", ...]
-                foreach ($schema->required as $required) {
-                    if (!$this->getTypeCheck()->propertyExists($value, $required)) {
-                        $this->addError(
-                            $this->incrementPath($path ?: new JsonPointer(''), $required),
-                            'The property ' . $required . ' is required',
-                            'required'
-                        );
-                    }
-                }
-            } elseif (isset($schema->required) && !is_array($schema->required)) {
-                // Draft 3 - Required attribute - e.g. "foo": {"type": "string", "required": true}
-                if ($schema->required && $value instanceof self) {
-                    $propertyPaths = $path->getPropertyPaths();
-                    $propertyName = end($propertyPaths);
-                    $this->addError(
-                        $path,
-                        'The property ' . $propertyName . ' is required',
-                        'required'
-                    );
-                }
-            } else {
-                // if the value is both undefined and not required, skip remaining checks
-                // in this method which assume an actual, defined instance when validating.
-                if ($value instanceof self) {
-                    return;
-                }
-            }
-        }
-
-        // Verify type
-        if (!($value instanceof self)) {
-            $this->checkType($value, $schema, $path, $i);
-        }
-
-        // Verify disallowed items
-        if (isset($schema->disallow)) {
-            $initErrors = $this->getErrors();
-
-            $typeSchema = new \stdClass();
-            $typeSchema->type = $schema->disallow;
-            $this->checkType($value, $typeSchema, $path);
-
-            // if no new errors were raised it must be a disallowed value
-            if (count($this->getErrors()) == count($initErrors)) {
-                $this->addError($path, 'Disallowed value was matched', 'disallow');
-            } else {
-                $this->errors = $initErrors;
-            }
-        }
-
-        if (isset($schema->not)) {
-            $initErrors = $this->getErrors();
-            $this->checkUndefined($value, $schema->not, $path, $i);
-
-            // if no new errors were raised then the instance validated against the "not" schema
-            if (count($this->getErrors()) == count($initErrors)) {
-                $this->addError($path, 'Matched a schema which it should not', 'not');
-            } else {
-                $this->errors = $initErrors;
-            }
-        }
-
-        // Verify that dependencies are met
-        if (isset($schema->dependencies) && $this->getTypeCheck()->isObject($value)) {
-            $this->validateDependencies($value, $schema->dependencies, $path);
-        }
-    }
-
-    /**
-     * Check whether a default should be applied for this value
-     *
-     * @param mixed $schema
-     * @param mixed $parentSchema
-     * @param bool  $requiredOnly
-     *
-     * @return bool
-     */
-    private function shouldApplyDefaultValue($requiredOnly, $schema, $name = null, $parentSchema = null)
-    {
-        // required-only mode is off
-        if (!$requiredOnly) {
-            return true;
-        }
-        // draft-04 required is set
-        if (
-            $name !== null
-            && isset($parentSchema->required)
-            && is_array($parentSchema->required)
-            && in_array($name, $parentSchema->required)
-        ) {
-            return true;
-        }
-        // draft-03 required is set
-        if (isset($schema->required) && !is_array($schema->required) && $schema->required) {
-            return true;
-        }
-        // default case
-        return false;
-    }
-
-    /**
-     * Apply default values
-     *
-     * @param mixed       $value
-     * @param mixed       $schema
-     * @param JsonPointer $path
-     */
-    protected function applyDefaultValues(&$value, $schema, $path)
-    {
-        // only apply defaults if feature is enabled
-        if (!$this->factory->getConfig(self::CHECK_MODE_APPLY_DEFAULTS)) {
-            return;
-        }
-
-        // apply defaults if appropriate
-        $requiredOnly = $this->factory->getConfig(self::CHECK_MODE_ONLY_REQUIRED_DEFAULTS);
-        if (isset($schema->properties) && LooseTypeCheck::isObject($value)) {
-            // $value is an object or assoc array, and properties are defined - treat as an object
-            foreach ($schema->properties as $currentProperty => $propertyDefinition) {
-                $propertyDefinition = $this->factory->getSchemaStorage()->resolveRefSchema($propertyDefinition);
-                if (
-                    !LooseTypeCheck::propertyExists($value, $currentProperty)
-                    && property_exists($propertyDefinition, 'default')
-                    && $this->shouldApplyDefaultValue($requiredOnly, $propertyDefinition, $currentProperty, $schema)
-                ) {
-                    // assign default value
-                    if (is_object($propertyDefinition->default)) {
-                        LooseTypeCheck::propertySet($value, $currentProperty, clone $propertyDefinition->default);
-                    } else {
-                        LooseTypeCheck::propertySet($value, $currentProperty, $propertyDefinition->default);
-                    }
-                    $this->appliedDefaults[] = $currentProperty;
-                }
-            }
-        } elseif (isset($schema->items) && LooseTypeCheck::isArray($value)) {
-            $items = array();
-            if (LooseTypeCheck::isArray($schema->items)) {
-                $items = $schema->items;
-            } elseif (isset($schema->minItems) && count($value) < $schema->minItems) {
-                $items = array_fill(count($value), $schema->minItems - count($value), $schema->items);
-            }
-            // $value is an array, and items are defined - treat as plain array
-            foreach ($items as $currentItem => $itemDefinition) {
-                $itemDefinition = $this->factory->getSchemaStorage()->resolveRefSchema($itemDefinition);
-                if (
-                    !array_key_exists($currentItem, $value)
-                    && property_exists($itemDefinition, 'default')
-                    && $this->shouldApplyDefaultValue($requiredOnly, $itemDefinition)) {
-                    if (is_object($itemDefinition->default)) {
-                        $value[$currentItem] = clone $itemDefinition->default;
-                    } else {
-                        $value[$currentItem] = $itemDefinition->default;
-                    }
-                }
-                $path->setFromDefault();
-            }
-        } elseif (
-            $value instanceof self
-            && property_exists($schema, 'default')
-            && $this->shouldApplyDefaultValue($requiredOnly, $schema)) {
-            // $value is a leaf, not a container - apply the default directly
-            $value = is_object($schema->default) ? clone $schema->default : $schema->default;
-            $path->setFromDefault();
-        }
-    }
-
-    /**
-     * Validate allOf, anyOf, and oneOf properties
-     *
-     * @param mixed       $value
-     * @param mixed       $schema
-     * @param JsonPointer $path
-     * @param string      $i
-     */
-    protected function validateOfProperties(&$value, $schema, JsonPointer $path, $i = '')
-    {
-        // Verify type
-        if ($value instanceof self) {
-            return;
-        }
-
-        if (isset($schema->allOf)) {
-            $isValid = true;
-            foreach ($schema->allOf as $allOf) {
-                $initErrors = $this->getErrors();
-                $this->checkUndefined($value, $allOf, $path, $i);
-                $isValid = $isValid && (count($this->getErrors()) == count($initErrors));
-            }
-            if (!$isValid) {
-                $this->addError($path, 'Failed to match all schemas', 'allOf');
-            }
-        }
-
-        if (isset($schema->anyOf)) {
-            $isValid = false;
-            $startErrors = $this->getErrors();
-            $caughtException = null;
-            foreach ($schema->anyOf as $anyOf) {
-                $initErrors = $this->getErrors();
-                try {
-                    $this->checkUndefined($value, $anyOf, $path, $i);
-                    if ($isValid = (count($this->getErrors()) == count($initErrors))) {
-                        break;
-                    }
-                } catch (ValidationException $e) {
-                    $isValid = false;
-                }
-            }
-            if (!$isValid) {
-                $this->addError($path, 'Failed to match at least one schema', 'anyOf');
-            } else {
-                $this->errors = $startErrors;
-            }
-        }
-
-        if (isset($schema->oneOf)) {
-            $allErrors = array();
-            $matchedSchemas = 0;
-            $startErrors = $this->getErrors();
-            foreach ($schema->oneOf as $oneOf) {
-                try {
-                    $this->errors = array();
-                    $this->checkUndefined($value, $oneOf, $path, $i);
-                    if (count($this->getErrors()) == 0) {
-                        $matchedSchemas++;
-                    }
-                    $allErrors = array_merge($allErrors, array_values($this->getErrors()));
-                } catch (ValidationException $e) {
-                    // deliberately do nothing here - validation failed, but we want to check
-                    // other schema options in the OneOf field.
-                }
-            }
-            if ($matchedSchemas !== 1) {
-                $this->addErrors(array_merge($allErrors, $startErrors));
-                $this->addError($path, 'Failed to match exactly one schema', 'oneOf');
-            } else {
-                $this->errors = $startErrors;
-            }
-        }
-    }
-
-    /**
-     * Validate dependencies
-     *
-     * @param mixed       $value
-     * @param mixed       $dependencies
-     * @param JsonPointer $path
-     * @param string      $i
-     */
-    protected function validateDependencies($value, $dependencies, JsonPointer $path, $i = '')
-    {
-        foreach ($dependencies as $key => $dependency) {
-            if ($this->getTypeCheck()->propertyExists($value, $key)) {
-                if (is_string($dependency)) {
-                    // Draft 3 string is allowed - e.g. "dependencies": {"bar": "foo"}
-                    if (!$this->getTypeCheck()->propertyExists($value, $dependency)) {
-                        $this->addError($path, "$key depends on $dependency and $dependency is missing", 'dependencies');
-                    }
-                } elseif (is_array($dependency)) {
-                    // Draft 4 must be an array - e.g. "dependencies": {"bar": ["foo"]}
-                    foreach ($dependency as $d) {
-                        if (!$this->getTypeCheck()->propertyExists($value, $d)) {
-                            $this->addError($path, "$key depends on $d and $d is missing", 'dependencies');
-                        }
-                    }
-                } elseif (is_object($dependency)) {
-                    // Schema - e.g. "dependencies": {"bar": {"properties": {"foo": {...}}}}
-                    $this->checkUndefined($value, $dependency, $path, $i);
-                }
-            }
-        }
-    }
-
-    protected function validateUri($schema, $schemaUri = null)
-    {
-        $resolver = new UriResolver();
-        $retriever = $this->factory->getUriRetriever();
-
-        $jsonSchema = null;
-        if ($resolver->isValid($schemaUri)) {
-            $schemaId = property_exists($schema, 'id') ? $schema->id : null;
-            $jsonSchema = $retriever->retrieve($schemaId, $schemaUri);
-        }
-
-        return $jsonSchema;
-    }
-}