gravityview / GravityView

vendor/justinrainbow/json-schema/src/JsonSchema/Entity/JsonPointer.php

Indentation +140 added lines, -140 removed lines

@@ -18,144 +18,144 @@
  */
 class JsonPointer
 {
-    /** @var string */
-    private $filename;
-
-    /** @var string[] */
-    private $propertyPaths = array();
-
-    /**
-     * @var bool Whether the value at this path was set from a schema default
-     */
-    private $fromDefault = false;
-
-    /**
-     * @param string $value
-     *
-     * @throws InvalidArgumentException when $value is not a string
-     */
-    public function __construct($value)
-    {
-        if (!is_string($value)) {
-            throw new InvalidArgumentException('Ref value must be a string');
-        }
-
-        $splitRef = explode('#', $value, 2);
-        $this->filename = $splitRef[0];
-        if (array_key_exists(1, $splitRef)) {
-            $this->propertyPaths = $this->decodePropertyPaths($splitRef[1]);
-        }
-    }
-
-    /**
-     * @param string $propertyPathString
-     *
-     * @return string[]
-     */
-    private function decodePropertyPaths($propertyPathString)
-    {
-        $paths = array();
-        foreach (explode('/', trim($propertyPathString, '/')) as $path) {
-            $path = $this->decodePath($path);
-            if (is_string($path) && '' !== $path) {
-                $paths[] = $path;
-            }
-        }
-
-        return $paths;
-    }
-
-    /**
-     * @return array
-     */
-    private function encodePropertyPaths()
-    {
-        return array_map(
-            array($this, 'encodePath'),
-            $this->getPropertyPaths()
-        );
-    }
-
-    /**
-     * @param string $path
-     *
-     * @return string
-     */
-    private function decodePath($path)
-    {
-        return strtr($path, array('~1' => '/', '~0' => '~', '%25' => '%'));
-    }
-
-    /**
-     * @param string $path
-     *
-     * @return string
-     */
-    private function encodePath($path)
-    {
-        return strtr($path, array('/' => '~1', '~' => '~0', '%' => '%25'));
-    }
-
-    /**
-     * @return string
-     */
-    public function getFilename()
-    {
-        return $this->filename;
-    }
-
-    /**
-     * @return string[]
-     */
-    public function getPropertyPaths()
-    {
-        return $this->propertyPaths;
-    }
-
-    /**
-     * @param array $propertyPaths
-     *
-     * @return JsonPointer
-     */
-    public function withPropertyPaths(array $propertyPaths)
-    {
-        $new = clone $this;
-        $new->propertyPaths = $propertyPaths;
-
-        return $new;
-    }
-
-    /**
-     * @return string
-     */
-    public function getPropertyPathAsString()
-    {
-        return rtrim('#/' . implode('/', $this->encodePropertyPaths()), '/');
-    }
-
-    /**
-     * @return string
-     */
-    public function __toString()
-    {
-        return $this->getFilename() . $this->getPropertyPathAsString();
-    }
-
-    /**
-     * Mark the value at this path as being set from a schema default
-     */
-    public function setFromDefault()
-    {
-        $this->fromDefault = true;
-    }
-
-    /**
-     * Check whether the value at this path was set from a schema default
-     *
-     * @return bool
-     */
-    public function fromDefault()
-    {
-        return $this->fromDefault;
-    }
+	/** @var string */
+	private $filename;
+
+	/** @var string[] */
+	private $propertyPaths = array();
+
+	/**
+	 * @var bool Whether the value at this path was set from a schema default
+	 */
+	private $fromDefault = false;
+
+	/**
+	 * @param string $value
+	 *
+	 * @throws InvalidArgumentException when $value is not a string
+	 */
+	public function __construct($value)
+	{
+		if (!is_string($value)) {
+			throw new InvalidArgumentException('Ref value must be a string');
+		}
+
+		$splitRef = explode('#', $value, 2);
+		$this->filename = $splitRef[0];
+		if (array_key_exists(1, $splitRef)) {
+			$this->propertyPaths = $this->decodePropertyPaths($splitRef[1]);
+		}
+	}
+
+	/**
+	 * @param string $propertyPathString
+	 *
+	 * @return string[]
+	 */
+	private function decodePropertyPaths($propertyPathString)
+	{
+		$paths = array();
+		foreach (explode('/', trim($propertyPathString, '/')) as $path) {
+			$path = $this->decodePath($path);
+			if (is_string($path) && '' !== $path) {
+				$paths[] = $path;
+			}
+		}
+
+		return $paths;
+	}
+
+	/**
+	 * @return array
+	 */
+	private function encodePropertyPaths()
+	{
+		return array_map(
+			array($this, 'encodePath'),
+			$this->getPropertyPaths()
+		);
+	}
+
+	/**
+	 * @param string $path
+	 *
+	 * @return string
+	 */
+	private function decodePath($path)
+	{
+		return strtr($path, array('~1' => '/', '~0' => '~', '%25' => '%'));
+	}
+
+	/**
+	 * @param string $path
+	 *
+	 * @return string
+	 */
+	private function encodePath($path)
+	{
+		return strtr($path, array('/' => '~1', '~' => '~0', '%' => '%25'));
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getFilename()
+	{
+		return $this->filename;
+	}
+
+	/**
+	 * @return string[]
+	 */
+	public function getPropertyPaths()
+	{
+		return $this->propertyPaths;
+	}
+
+	/**
+	 * @param array $propertyPaths
+	 *
+	 * @return JsonPointer
+	 */
+	public function withPropertyPaths(array $propertyPaths)
+	{
+		$new = clone $this;
+		$new->propertyPaths = $propertyPaths;
+
+		return $new;
+	}
+
+	/**
+	 * @return string
+	 */
+	public function getPropertyPathAsString()
+	{
+		return rtrim('#/' . implode('/', $this->encodePropertyPaths()), '/');
+	}
+
+	/**
+	 * @return string
+	 */
+	public function __toString()
+	{
+		return $this->getFilename() . $this->getPropertyPathAsString();
+	}
+
+	/**
+	 * Mark the value at this path as being set from a schema default
+	 */
+	public function setFromDefault()
+	{
+		$this->fromDefault = true;
+	}
+
+	/**
+	 * Check whether the value at this path was set from a schema default
+	 *
+	 * @return bool
+	 */
+	public function fromDefault()
+	{
+		return $this->fromDefault;
+	}
 }

vendor/justinrainbow/json-schema/src/JsonSchema/UriRetrieverInterface.php

Indentation +9 added lines, -9 removed lines

@@ -14,13 +14,13 @@
  */
 interface UriRetrieverInterface
 {
-    /**
-     * Retrieve a URI
-     *
-     * @param string      $uri     JSON Schema URI
-     * @param null|string $baseUri
-     *
-     * @return object JSON Schema contents
-     */
-    public function retrieve($uri, $baseUri = null);
+	/**
+	 * Retrieve a URI
+	 *
+	 * @param string      $uri     JSON Schema URI
+	 * @param null|string $baseUri
+	 *
+	 * @return object JSON Schema contents
+	 */
+	public function retrieve($uri, $baseUri = null);
 }

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

Indentation +52 added lines, -52 removed lines

@@ -4,65 +4,65 @@
 
 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 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 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};
-        }
+	public static function propertyGet($value, $property)
+	{
+		if (is_object($value)) {
+			return $value->{$property};
+		}
 
-        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 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);
-        }
+	public static function propertyExists($value, $property)
+	{
+		if (is_object($value)) {
+			return property_exists($value, $property);
+		}
 
-        return array_key_exists($property, $value);
-    }
+		return array_key_exists($property, $value);
+	}
 
-    public static function propertyCount($value)
-    {
-        if (is_object($value)) {
-            return count(get_object_vars($value));
-        }
+	public static function propertyCount($value)
+	{
+		if (is_object($value)) {
+			return count(get_object_vars($value));
+		}
 
-        return count($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);
-    }
+	/**
+	 * 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);
+	}
 }

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

Indentation +6 added lines, -6 removed lines

@@ -4,15 +4,15 @@
 
 interface TypeCheckInterface
 {
-    public static function isObject($value);
+	public static function isObject($value);
 
-    public static function isArray($value);
+	public static function isArray($value);
 
-    public static function propertyGet($value, $property);
+	public static function propertyGet($value, $property);
 
-    public static function propertySet(&$value, $property, $data);
+	public static function propertySet(&$value, $property, $data);
 
-    public static function propertyExists($value, $property);
+	public static function propertyExists($value, $property);
 
-    public static function propertyCount($value);
+	public static function propertyCount($value);
 }

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

Indentation +33 added lines, -33 removed lines

@@ -4,37 +4,37 @@
 
 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));
-    }
+	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));
+	}
 }

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

Indentation +89 added lines, -89 removed lines

@@ -19,103 +19,103 @@
  */
 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));
-        }
+	/**
+	 * {@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 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 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);
-        }
-    }
+		// 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
-            foreach ($value as $k => &$v) {
-                $initErrors = $this->getErrors();
+	/**
+	 * 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
+			foreach ($value as $k => &$v) {
+				$initErrors = $this->getErrors();
 
-                // First check if its defined in "items"
-                $this->checkUndefined($v, $schema->items, $path, $k);
+				// 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);
-                }
+				// 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
+				// 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
+		} 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);
-                }
-            }
-        }
-    }
+			// 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);
+				}
+			}
+		}
+	}
 }

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

Indentation +196 added lines, -196 removed lines

@@ -19,200 +19,200 @@
  */
 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('');
-
-        if ($i === null || $i === '') {
-            return $path;
-        }
-
-        $path = $path->withPropertyPaths(
-            array_merge(
-                $path->getPropertyPaths(),
-                array($i)
-            )
-        );
-
-        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), '.');
-    }
+	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('');
+
+		if ($i === null || $i === '') {
+			return $path;
+		}
+
+		$path = $path->withPropertyPaths(
+			array_merge(
+				$path->getPropertyPaths(),
+				array($i)
+			)
+		);
+
+		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), '.');
+	}
 }

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

Indentation +29 added lines, -29 removed lines

@@ -19,36 +19,36 @@
  */
 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);
+	/**
+	 * {@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;
-                }
-            }
+		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;
-                }
-            }
-        }
+			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));
-    }
+		$this->addError($path, 'Does not have a value in the enumeration ' . json_encode($schema->enum), 'enum', array('enum' => $schema->enum));
+	}
 }

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

Indentation +237 added lines, -237 removed lines

@@ -21,241 +21,241 @@
  */
 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;
-    }
+	/**
+	 * @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;
+	}
 }