gravityview / GravityView

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

Indentation +52 added lines, -52 removed lines

@@ -19,63 +19,63 @@
  */
 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));
-        }
+	/**
+	 * {@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 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 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));
-        }
+		// 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);
-    }
+		$this->checkFormat($element, $schema, $path, $i);
+	}
 
-    private function fmod($number1, $number2)
-    {
-        $modulus = ($number1 - round($number1 / $number2) * $number2);
-        $precision = 0.0000000001;
+	private function fmod($number1, $number2)
+	{
+		$modulus = ($number1 - round($number1 / $number2) * $number2);
+		$precision = 0.0000000001;
 
-        if (-$precision < $modulus && $modulus < $precision) {
-            return 0.0;
-        }
+		if (-$precision < $modulus && $modulus < $precision) {
+			return 0.0;
+		}
 
-        return $modulus;
-    }
+		return $modulus;
+	}
 }

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

Indentation +190 added lines, -190 removed lines

@@ -21,194 +21,194 @@
  */
 class FormatConstraint extends Constraint
 {
-    /**
-     * {@inheritdoc}
-     */
-    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
-    {
-        if (!isset($schema->format) || $this->factory->getConfig(self::CHECK_MODE_DISABLE_FORMAT)) {
-            return;
-        }
-
-        switch ($schema->format) {
-            case 'date':
-                if (!$date = $this->validateDateTime($element, 'Y-m-d')) {
-                    $this->addError($path, sprintf('Invalid date %s, expected format YYYY-MM-DD', json_encode($element)), 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'time':
-                if (!$this->validateDateTime($element, 'H:i:s')) {
-                    $this->addError($path, sprintf('Invalid time %s, expected format hh:mm:ss', json_encode($element)), 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'date-time':
-                if (null === Rfc3339::createFromString($element)) {
-                    $this->addError($path, sprintf('Invalid date-time %s, expected format YYYY-MM-DDThh:mm:ssZ or YYYY-MM-DDThh:mm:ss+hh:mm', json_encode($element)), 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'utc-millisec':
-                if (!$this->validateDateTime($element, 'U')) {
-                    $this->addError($path, sprintf('Invalid time %s, expected integer of milliseconds since Epoch', json_encode($element)), 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'regex':
-                if (!$this->validateRegex($element)) {
-                    $this->addError($path, 'Invalid regex format ' . $element, 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'color':
-                if (!$this->validateColor($element)) {
-                    $this->addError($path, 'Invalid color', 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'style':
-                if (!$this->validateStyle($element)) {
-                    $this->addError($path, 'Invalid style', 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'phone':
-                if (!$this->validatePhone($element)) {
-                    $this->addError($path, 'Invalid phone number', 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'uri':
-                if (null === filter_var($element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE)) {
-                    $this->addError($path, 'Invalid URL format', 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'uriref':
-            case 'uri-reference':
-                if (null === filter_var($element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE)) {
-                    // FILTER_VALIDATE_URL does not conform to RFC-3986, and cannot handle relative URLs, but
-                    // the json-schema spec uses RFC-3986, so need a bit of hackery to properly validate them.
-                    // See https://tools.ietf.org/html/rfc3986#section-4.2 for additional information.
-                    if (substr($element, 0, 2) === '//') { // network-path reference
-                        $validURL = filter_var('scheme:' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
-                    } elseif (substr($element, 0, 1) === '/') { // absolute-path reference
-                        $validURL = filter_var('scheme://host' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
-                    } elseif (strlen($element)) { // relative-path reference
-                        $pathParts = explode('/', $element, 2);
-                        if (strpos($pathParts[0], ':') !== false) {
-                            $validURL = null;
-                        } else {
-                            $validURL = filter_var('scheme://host/' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
-                        }
-                    } else {
-                        $validURL = null;
-                    }
-                    if ($validURL === null) {
-                        $this->addError($path, 'Invalid URL format', 'format', array('format' => $schema->format));
-                    }
-                }
-                break;
-
-            case 'email':
-                $filterFlags = FILTER_NULL_ON_FAILURE;
-                if (defined('FILTER_FLAG_EMAIL_UNICODE')) {
-                    // Only available from PHP >= 7.1.0, so ignore it for coverage checks
-                    $filterFlags |= constant('FILTER_FLAG_EMAIL_UNICODE'); // @codeCoverageIgnore
-                }
-                if (null === filter_var($element, FILTER_VALIDATE_EMAIL, $filterFlags)) {
-                    $this->addError($path, 'Invalid email', 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'ip-address':
-            case 'ipv4':
-                if (null === filter_var($element, FILTER_VALIDATE_IP, FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4)) {
-                    $this->addError($path, 'Invalid IP address', 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'ipv6':
-                if (null === filter_var($element, FILTER_VALIDATE_IP, FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV6)) {
-                    $this->addError($path, 'Invalid IP address', 'format', array('format' => $schema->format));
-                }
-                break;
-
-            case 'host-name':
-            case 'hostname':
-                if (!$this->validateHostname($element)) {
-                    $this->addError($path, 'Invalid hostname', 'format', array('format' => $schema->format));
-                }
-                break;
-
-            default:
-                // Empty as it should be:
-                // The value of this keyword is called a format attribute. It MUST be a string.
-                // A format attribute can generally only validate a given set of instance types.
-                // If the type of the instance to validate is not in this set, validation for
-                // this format attribute and instance SHOULD succeed.
-                // http://json-schema.org/latest/json-schema-validation.html#anchor105
-                break;
-        }
-    }
-
-    protected function validateDateTime($datetime, $format)
-    {
-        $dt = \DateTime::createFromFormat($format, $datetime);
-
-        if (!$dt) {
-            return false;
-        }
-
-        if ($datetime === $dt->format($format)) {
-            return true;
-        }
-
-        // handles the case where a non-6 digit microsecond datetime is passed
-        // which will fail the above string comparison because the passed
-        // $datetime may be '2000-05-01T12:12:12.123Z' but format() will return
-        // '2000-05-01T12:12:12.123000Z'
-        if ((strpos('u', $format) !== -1) && (preg_match('/\.\d+Z$/', $datetime))) {
-            return true;
-        }
-
-        return false;
-    }
-
-    protected function validateRegex($regex)
-    {
-        return false !== @preg_match('/' . $regex . '/u', '');
-    }
-
-    protected function validateColor($color)
-    {
-        if (in_array(strtolower($color), array('aqua', 'black', 'blue', 'fuchsia',
-            'gray', 'green', 'lime', 'maroon', 'navy', 'olive', 'orange', 'purple',
-            'red', 'silver', 'teal', 'white', 'yellow'))) {
-            return true;
-        }
-
-        return preg_match('/^#([a-f0-9]{3}|[a-f0-9]{6})$/i', $color);
-    }
-
-    protected function validateStyle($style)
-    {
-        $properties     = explode(';', rtrim($style, ';'));
-        $invalidEntries = preg_grep('/^\s*[-a-z]+\s*:\s*.+$/i', $properties, PREG_GREP_INVERT);
-
-        return empty($invalidEntries);
-    }
-
-    protected function validatePhone($phone)
-    {
-        return preg_match('/^\+?(\(\d{3}\)|\d{3}) \d{3} \d{4}$/', $phone);
-    }
-
-    protected function validateHostname($host)
-    {
-        $hostnameRegex = '/^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/i';
-
-        return preg_match($hostnameRegex, $host);
-    }
+	/**
+	 * {@inheritdoc}
+	 */
+	public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+	{
+		if (!isset($schema->format) || $this->factory->getConfig(self::CHECK_MODE_DISABLE_FORMAT)) {
+			return;
+		}
+
+		switch ($schema->format) {
+			case 'date':
+				if (!$date = $this->validateDateTime($element, 'Y-m-d')) {
+					$this->addError($path, sprintf('Invalid date %s, expected format YYYY-MM-DD', json_encode($element)), 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'time':
+				if (!$this->validateDateTime($element, 'H:i:s')) {
+					$this->addError($path, sprintf('Invalid time %s, expected format hh:mm:ss', json_encode($element)), 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'date-time':
+				if (null === Rfc3339::createFromString($element)) {
+					$this->addError($path, sprintf('Invalid date-time %s, expected format YYYY-MM-DDThh:mm:ssZ or YYYY-MM-DDThh:mm:ss+hh:mm', json_encode($element)), 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'utc-millisec':
+				if (!$this->validateDateTime($element, 'U')) {
+					$this->addError($path, sprintf('Invalid time %s, expected integer of milliseconds since Epoch', json_encode($element)), 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'regex':
+				if (!$this->validateRegex($element)) {
+					$this->addError($path, 'Invalid regex format ' . $element, 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'color':
+				if (!$this->validateColor($element)) {
+					$this->addError($path, 'Invalid color', 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'style':
+				if (!$this->validateStyle($element)) {
+					$this->addError($path, 'Invalid style', 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'phone':
+				if (!$this->validatePhone($element)) {
+					$this->addError($path, 'Invalid phone number', 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'uri':
+				if (null === filter_var($element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE)) {
+					$this->addError($path, 'Invalid URL format', 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'uriref':
+			case 'uri-reference':
+				if (null === filter_var($element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE)) {
+					// FILTER_VALIDATE_URL does not conform to RFC-3986, and cannot handle relative URLs, but
+					// the json-schema spec uses RFC-3986, so need a bit of hackery to properly validate them.
+					// See https://tools.ietf.org/html/rfc3986#section-4.2 for additional information.
+					if (substr($element, 0, 2) === '//') { // network-path reference
+						$validURL = filter_var('scheme:' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
+					} elseif (substr($element, 0, 1) === '/') { // absolute-path reference
+						$validURL = filter_var('scheme://host' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
+					} elseif (strlen($element)) { // relative-path reference
+						$pathParts = explode('/', $element, 2);
+						if (strpos($pathParts[0], ':') !== false) {
+							$validURL = null;
+						} else {
+							$validURL = filter_var('scheme://host/' . $element, FILTER_VALIDATE_URL, FILTER_NULL_ON_FAILURE);
+						}
+					} else {
+						$validURL = null;
+					}
+					if ($validURL === null) {
+						$this->addError($path, 'Invalid URL format', 'format', array('format' => $schema->format));
+					}
+				}
+				break;
+
+			case 'email':
+				$filterFlags = FILTER_NULL_ON_FAILURE;
+				if (defined('FILTER_FLAG_EMAIL_UNICODE')) {
+					// Only available from PHP >= 7.1.0, so ignore it for coverage checks
+					$filterFlags |= constant('FILTER_FLAG_EMAIL_UNICODE'); // @codeCoverageIgnore
+				}
+				if (null === filter_var($element, FILTER_VALIDATE_EMAIL, $filterFlags)) {
+					$this->addError($path, 'Invalid email', 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'ip-address':
+			case 'ipv4':
+				if (null === filter_var($element, FILTER_VALIDATE_IP, FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV4)) {
+					$this->addError($path, 'Invalid IP address', 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'ipv6':
+				if (null === filter_var($element, FILTER_VALIDATE_IP, FILTER_NULL_ON_FAILURE | FILTER_FLAG_IPV6)) {
+					$this->addError($path, 'Invalid IP address', 'format', array('format' => $schema->format));
+				}
+				break;
+
+			case 'host-name':
+			case 'hostname':
+				if (!$this->validateHostname($element)) {
+					$this->addError($path, 'Invalid hostname', 'format', array('format' => $schema->format));
+				}
+				break;
+
+			default:
+				// Empty as it should be:
+				// The value of this keyword is called a format attribute. It MUST be a string.
+				// A format attribute can generally only validate a given set of instance types.
+				// If the type of the instance to validate is not in this set, validation for
+				// this format attribute and instance SHOULD succeed.
+				// http://json-schema.org/latest/json-schema-validation.html#anchor105
+				break;
+		}
+	}
+
+	protected function validateDateTime($datetime, $format)
+	{
+		$dt = \DateTime::createFromFormat($format, $datetime);
+
+		if (!$dt) {
+			return false;
+		}
+
+		if ($datetime === $dt->format($format)) {
+			return true;
+		}
+
+		// handles the case where a non-6 digit microsecond datetime is passed
+		// which will fail the above string comparison because the passed
+		// $datetime may be '2000-05-01T12:12:12.123Z' but format() will return
+		// '2000-05-01T12:12:12.123000Z'
+		if ((strpos('u', $format) !== -1) && (preg_match('/\.\d+Z$/', $datetime))) {
+			return true;
+		}
+
+		return false;
+	}
+
+	protected function validateRegex($regex)
+	{
+		return false !== @preg_match('/' . $regex . '/u', '');
+	}
+
+	protected function validateColor($color)
+	{
+		if (in_array(strtolower($color), array('aqua', 'black', 'blue', 'fuchsia',
+			'gray', 'green', 'lime', 'maroon', 'navy', 'olive', 'orange', 'purple',
+			'red', 'silver', 'teal', 'white', 'yellow'))) {
+			return true;
+		}
+
+		return preg_match('/^#([a-f0-9]{3}|[a-f0-9]{6})$/i', $color);
+	}
+
+	protected function validateStyle($style)
+	{
+		$properties     = explode(';', rtrim($style, ';'));
+		$invalidEntries = preg_grep('/^\s*[-a-z]+\s*:\s*.+$/i', $properties, PREG_GREP_INVERT);
+
+		return empty($invalidEntries);
+	}
+
+	protected function validatePhone($phone)
+	{
+		return preg_match('/^\+?(\(\d{3}\)|\d{3}) \d{3} \d{4}$/', $phone);
+	}
+
+	protected function validateHostname($host)
+	{
+		$hostnameRegex = '/^(([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9\-]*[a-zA-Z0-9])\.)*([A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9\-]*[A-Za-z0-9])$/i';
+
+		return preg_match($hostnameRegex, $host);
+	}
 }

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

Indentation +38 added lines, -38 removed lines

@@ -19,42 +19,42 @@
  */
 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
-    }
+	/**
+	 * {@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
+	}
 }

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

Indentation +60 added lines, -60 removed lines

@@ -23,72 +23,72 @@
  */
 class SchemaConstraint extends Constraint
 {
-    const DEFAULT_SCHEMA_SPEC = 'http://json-schema.org/draft-04/schema#';
+	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');
-        }
+	/**
+	 * {@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);
-        }
+		// 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;
-            }
+		// 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);
-            }
+			// 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);
+			// 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');
-            }
+			// 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);
-        }
+			// restore the initial config
+			$this->factory->setConfig($initialConfig);
+			$this->factory->setErrorContext($initialContext);
+		}
 
-        // validate element against $validationSchema
-        $this->checkUndefined($element, $validationSchema, $path, $i);
-    }
+		// validate element against $validationSchema
+		$this->checkUndefined($element, $validationSchema, $path, $i);
+	}
 }

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

Indentation +170 added lines, -170 removed lines

@@ -19,174 +19,174 @@
  */
 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));
-            }
-        }
-    }
+	/**
+	 * @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));
+			}
+		}
+	}
 }

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

Indentation +125 added lines, -125 removed lines

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

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

Indentation +40 added lines, -40 removed lines

@@ -18,48 +18,48 @@
  */
 interface ConstraintInterface
 {
-    /**
-     * returns all collected errors
-     *
-     * @return array
-     */
-    public function getErrors();
+	/**
+	 * returns all collected errors
+	 *
+	 * @return array
+	 */
+	public function getErrors();
 
-    /**
-     * adds errors to this validator
-     *
-     * @param array $errors
-     */
-    public function addErrors(array $errors);
+	/**
+	 * adds errors to this validator
+	 *
+	 * @param array $errors
+	 */
+	public function addErrors(array $errors);
 
-    /**
-     * adds an error
-     *
-     * @param JsonPointer|null $path
-     * @param string           $message
-     * @param string           $constraint the constraint/rule that is broken, e.g.: 'minLength'
-     * @param array            $more       more array elements to add to the error
-     */
-    public function addError(JsonPointer $path = null, $message, $constraint='', array $more = null);
+	/**
+	 * adds an error
+	 *
+	 * @param JsonPointer|null $path
+	 * @param string           $message
+	 * @param string           $constraint the constraint/rule that is broken, e.g.: 'minLength'
+	 * @param array            $more       more array elements to add to the error
+	 */
+	public function addError(JsonPointer $path = null, $message, $constraint='', array $more = null);
 
-    /**
-     * checks if the validator has not raised errors
-     *
-     * @return bool
-     */
-    public function isValid();
+	/**
+	 * checks if the validator has not raised errors
+	 *
+	 * @return bool
+	 */
+	public function isValid();
 
-    /**
-     * invokes the validation of an element
-     *
-     * @abstract
-     *
-     * @param mixed            $value
-     * @param mixed            $schema
-     * @param JsonPointer|null $path
-     * @param mixed            $i
-     *
-     * @throws \JsonSchema\Exception\ExceptionInterface
-     */
-    public function check(&$value, $schema = null, JsonPointer $path = null, $i = null);
+	/**
+	 * invokes the validation of an element
+	 *
+	 * @abstract
+	 *
+	 * @param mixed            $value
+	 * @param mixed            $schema
+	 * @param JsonPointer|null $path
+	 * @param mixed            $i
+	 *
+	 * @throws \JsonSchema\Exception\ExceptionInterface
+	 */
+	public function check(&$value, $schema = null, JsonPointer $path = null, $i = null);
 }

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

Indentation +196 added lines, -196 removed lines

@@ -21,200 +21,200 @@
  */
 class Factory
 {
-    /**
-     * @var SchemaStorage
-     */
-    protected $schemaStorage;
-
-    /**
-     * @var UriRetriever
-     */
-    protected $uriRetriever;
-
-    /**
-     * @var int
-     */
-    private $checkMode = Constraint::CHECK_MODE_NORMAL;
-
-    /**
-     * @var TypeCheck\TypeCheckInterface[]
-     */
-    private $typeCheck = array();
-
-    /**
-     * @var int Validation context
-     */
-    protected $errorContext = Validator::ERROR_DOCUMENT_VALIDATION;
-
-    /**
-     * @var array
-     */
-    protected $constraintMap = array(
-        'array' => 'JsonSchema\Constraints\CollectionConstraint',
-        'collection' => 'JsonSchema\Constraints\CollectionConstraint',
-        'object' => 'JsonSchema\Constraints\ObjectConstraint',
-        'type' => 'JsonSchema\Constraints\TypeConstraint',
-        'undefined' => 'JsonSchema\Constraints\UndefinedConstraint',
-        'string' => 'JsonSchema\Constraints\StringConstraint',
-        'number' => 'JsonSchema\Constraints\NumberConstraint',
-        'enum' => 'JsonSchema\Constraints\EnumConstraint',
-        'format' => 'JsonSchema\Constraints\FormatConstraint',
-        'schema' => 'JsonSchema\Constraints\SchemaConstraint',
-        'validator' => 'JsonSchema\Validator'
-    );
-
-    /**
-     * @var array<ConstraintInterface>
-     */
-    private $instanceCache = array();
-
-    /**
-     * @param SchemaStorage         $schemaStorage
-     * @param UriRetrieverInterface $uriRetriever
-     * @param int                   $checkMode
-     */
-    public function __construct(
-        SchemaStorageInterface $schemaStorage = null,
-        UriRetrieverInterface $uriRetriever = null,
-        $checkMode = Constraint::CHECK_MODE_NORMAL
-    ) {
-        // set provided config options
-        $this->setConfig($checkMode);
-
-        $this->uriRetriever = $uriRetriever ?: new UriRetriever();
-        $this->schemaStorage = $schemaStorage ?: new SchemaStorage($this->uriRetriever);
-    }
-
-    /**
-     * Set config values
-     *
-     * @param int $checkMode Set checkMode options - does not preserve existing flags
-     */
-    public function setConfig($checkMode = Constraint::CHECK_MODE_NORMAL)
-    {
-        $this->checkMode = $checkMode;
-    }
-
-    /**
-     * Enable checkMode flags
-     *
-     * @param int $options
-     */
-    public function addConfig($options)
-    {
-        $this->checkMode |= $options;
-    }
-
-    /**
-     * Disable checkMode flags
-     *
-     * @param int $options
-     */
-    public function removeConfig($options)
-    {
-        $this->checkMode &= ~$options;
-    }
-
-    /**
-     * Get checkMode option
-     *
-     * @param int $options Options to get, if null then return entire bitmask
-     *
-     * @return int
-     */
-    public function getConfig($options = null)
-    {
-        if ($options === null) {
-            return $this->checkMode;
-        }
-
-        return $this->checkMode & $options;
-    }
-
-    /**
-     * @return UriRetrieverInterface
-     */
-    public function getUriRetriever()
-    {
-        return $this->uriRetriever;
-    }
-
-    public function getSchemaStorage()
-    {
-        return $this->schemaStorage;
-    }
-
-    public function getTypeCheck()
-    {
-        if (!isset($this->typeCheck[$this->checkMode])) {
-            $this->typeCheck[$this->checkMode] = ($this->checkMode & Constraint::CHECK_MODE_TYPE_CAST)
-                ? new TypeCheck\LooseTypeCheck()
-                : new TypeCheck\StrictTypeCheck();
-        }
-
-        return $this->typeCheck[$this->checkMode];
-    }
-
-    /**
-     * @param string $name
-     * @param string $class
-     *
-     * @return Factory
-     */
-    public function setConstraintClass($name, $class)
-    {
-        // Ensure class exists
-        if (!class_exists($class)) {
-            throw new InvalidArgumentException('Unknown constraint ' . $name);
-        }
-        // Ensure class is appropriate
-        if (!in_array('JsonSchema\Constraints\ConstraintInterface', class_implements($class))) {
-            throw new InvalidArgumentException('Invalid class ' . $name);
-        }
-        $this->constraintMap[$name] = $class;
-
-        return $this;
-    }
-
-    /**
-     * Create a constraint instance for the given constraint name.
-     *
-     * @param string $constraintName
-     *
-     * @throws InvalidArgumentException if is not possible create the constraint instance
-     *
-     * @return ConstraintInterface|ObjectConstraint
-     */
-    public function createInstanceFor($constraintName)
-    {
-        if (!isset($this->constraintMap[$constraintName])) {
-            throw new InvalidArgumentException('Unknown constraint ' . $constraintName);
-        }
-
-        if (!isset($this->instanceCache[$constraintName])) {
-            $this->instanceCache[$constraintName] = new $this->constraintMap[$constraintName]($this);
-        }
-
-        return clone $this->instanceCache[$constraintName];
-    }
-
-    /**
-     * Get the error context
-     *
-     * @return string
-     */
-    public function getErrorContext()
-    {
-        return $this->errorContext;
-    }
-
-    /**
-     * Set the error context
-     *
-     * @param string $validationContext
-     */
-    public function setErrorContext($errorContext)
-    {
-        $this->errorContext = $errorContext;
-    }
+	/**
+	 * @var SchemaStorage
+	 */
+	protected $schemaStorage;
+
+	/**
+	 * @var UriRetriever
+	 */
+	protected $uriRetriever;
+
+	/**
+	 * @var int
+	 */
+	private $checkMode = Constraint::CHECK_MODE_NORMAL;
+
+	/**
+	 * @var TypeCheck\TypeCheckInterface[]
+	 */
+	private $typeCheck = array();
+
+	/**
+	 * @var int Validation context
+	 */
+	protected $errorContext = Validator::ERROR_DOCUMENT_VALIDATION;
+
+	/**
+	 * @var array
+	 */
+	protected $constraintMap = array(
+		'array' => 'JsonSchema\Constraints\CollectionConstraint',
+		'collection' => 'JsonSchema\Constraints\CollectionConstraint',
+		'object' => 'JsonSchema\Constraints\ObjectConstraint',
+		'type' => 'JsonSchema\Constraints\TypeConstraint',
+		'undefined' => 'JsonSchema\Constraints\UndefinedConstraint',
+		'string' => 'JsonSchema\Constraints\StringConstraint',
+		'number' => 'JsonSchema\Constraints\NumberConstraint',
+		'enum' => 'JsonSchema\Constraints\EnumConstraint',
+		'format' => 'JsonSchema\Constraints\FormatConstraint',
+		'schema' => 'JsonSchema\Constraints\SchemaConstraint',
+		'validator' => 'JsonSchema\Validator'
+	);
+
+	/**
+	 * @var array<ConstraintInterface>
+	 */
+	private $instanceCache = array();
+
+	/**
+	 * @param SchemaStorage         $schemaStorage
+	 * @param UriRetrieverInterface $uriRetriever
+	 * @param int                   $checkMode
+	 */
+	public function __construct(
+		SchemaStorageInterface $schemaStorage = null,
+		UriRetrieverInterface $uriRetriever = null,
+		$checkMode = Constraint::CHECK_MODE_NORMAL
+	) {
+		// set provided config options
+		$this->setConfig($checkMode);
+
+		$this->uriRetriever = $uriRetriever ?: new UriRetriever();
+		$this->schemaStorage = $schemaStorage ?: new SchemaStorage($this->uriRetriever);
+	}
+
+	/**
+	 * Set config values
+	 *
+	 * @param int $checkMode Set checkMode options - does not preserve existing flags
+	 */
+	public function setConfig($checkMode = Constraint::CHECK_MODE_NORMAL)
+	{
+		$this->checkMode = $checkMode;
+	}
+
+	/**
+	 * Enable checkMode flags
+	 *
+	 * @param int $options
+	 */
+	public function addConfig($options)
+	{
+		$this->checkMode |= $options;
+	}
+
+	/**
+	 * Disable checkMode flags
+	 *
+	 * @param int $options
+	 */
+	public function removeConfig($options)
+	{
+		$this->checkMode &= ~$options;
+	}
+
+	/**
+	 * Get checkMode option
+	 *
+	 * @param int $options Options to get, if null then return entire bitmask
+	 *
+	 * @return int
+	 */
+	public function getConfig($options = null)
+	{
+		if ($options === null) {
+			return $this->checkMode;
+		}
+
+		return $this->checkMode & $options;
+	}
+
+	/**
+	 * @return UriRetrieverInterface
+	 */
+	public function getUriRetriever()
+	{
+		return $this->uriRetriever;
+	}
+
+	public function getSchemaStorage()
+	{
+		return $this->schemaStorage;
+	}
+
+	public function getTypeCheck()
+	{
+		if (!isset($this->typeCheck[$this->checkMode])) {
+			$this->typeCheck[$this->checkMode] = ($this->checkMode & Constraint::CHECK_MODE_TYPE_CAST)
+				? new TypeCheck\LooseTypeCheck()
+				: new TypeCheck\StrictTypeCheck();
+		}
+
+		return $this->typeCheck[$this->checkMode];
+	}
+
+	/**
+	 * @param string $name
+	 * @param string $class
+	 *
+	 * @return Factory
+	 */
+	public function setConstraintClass($name, $class)
+	{
+		// Ensure class exists
+		if (!class_exists($class)) {
+			throw new InvalidArgumentException('Unknown constraint ' . $name);
+		}
+		// Ensure class is appropriate
+		if (!in_array('JsonSchema\Constraints\ConstraintInterface', class_implements($class))) {
+			throw new InvalidArgumentException('Invalid class ' . $name);
+		}
+		$this->constraintMap[$name] = $class;
+
+		return $this;
+	}
+
+	/**
+	 * Create a constraint instance for the given constraint name.
+	 *
+	 * @param string $constraintName
+	 *
+	 * @throws InvalidArgumentException if is not possible create the constraint instance
+	 *
+	 * @return ConstraintInterface|ObjectConstraint
+	 */
+	public function createInstanceFor($constraintName)
+	{
+		if (!isset($this->constraintMap[$constraintName])) {
+			throw new InvalidArgumentException('Unknown constraint ' . $constraintName);
+		}
+
+		if (!isset($this->instanceCache[$constraintName])) {
+			$this->instanceCache[$constraintName] = new $this->constraintMap[$constraintName]($this);
+		}
+
+		return clone $this->instanceCache[$constraintName];
+	}
+
+	/**
+	 * Get the error context
+	 *
+	 * @return string
+	 */
+	public function getErrorContext()
+	{
+		return $this->errorContext;
+	}
+
+	/**
+	 * Set the error context
+	 *
+	 * @param string $validationContext
+	 */
+	public function setErrorContext($errorContext)
+	{
+		$this->errorContext = $errorContext;
+	}
 }

vendor/justinrainbow/json-schema/src/JsonSchema/Uri/Retrievers/Curl.php

Indentation +50 added lines, -50 removed lines

@@ -19,65 +19,65 @@
  */
 class Curl extends AbstractRetriever
 {
-    protected $messageBody;
+	protected $messageBody;
 
-    public function __construct()
-    {
-        if (!function_exists('curl_init')) {
-            // Cannot test this, because curl_init is present on all test platforms plus mock
-            throw new RuntimeException('cURL not installed'); // @codeCoverageIgnore
-        }
-    }
+	public function __construct()
+	{
+		if (!function_exists('curl_init')) {
+			// Cannot test this, because curl_init is present on all test platforms plus mock
+			throw new RuntimeException('cURL not installed'); // @codeCoverageIgnore
+		}
+	}
 
-    /**
-     * {@inheritdoc}
-     *
-     * @see \JsonSchema\Uri\Retrievers\UriRetrieverInterface::retrieve()
-     */
-    public function retrieve($uri)
-    {
-        $ch = curl_init();
+	/**
+	 * {@inheritdoc}
+	 *
+	 * @see \JsonSchema\Uri\Retrievers\UriRetrieverInterface::retrieve()
+	 */
+	public function retrieve($uri)
+	{
+		$ch = curl_init();
 
-        curl_setopt($ch, CURLOPT_URL, $uri);
-        curl_setopt($ch, CURLOPT_HEADER, true);
-        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
-        curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: ' . Validator::SCHEMA_MEDIA_TYPE));
+		curl_setopt($ch, CURLOPT_URL, $uri);
+		curl_setopt($ch, CURLOPT_HEADER, true);
+		curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
+		curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: ' . Validator::SCHEMA_MEDIA_TYPE));
 
-        $response = curl_exec($ch);
-        if (false === $response) {
-            throw new \JsonSchema\Exception\ResourceNotFoundException('JSON schema not found');
-        }
+		$response = curl_exec($ch);
+		if (false === $response) {
+			throw new \JsonSchema\Exception\ResourceNotFoundException('JSON schema not found');
+		}
 
-        $this->fetchMessageBody($response);
-        $this->fetchContentType($response);
+		$this->fetchMessageBody($response);
+		$this->fetchContentType($response);
 
-        curl_close($ch);
+		curl_close($ch);
 
-        return $this->messageBody;
-    }
+		return $this->messageBody;
+	}
 
-    /**
-     * @param string $response cURL HTTP response
-     */
-    private function fetchMessageBody($response)
-    {
-        preg_match("/(?:\r\n){2}(.*)$/ms", $response, $match);
-        $this->messageBody = $match[1];
-    }
+	/**
+	 * @param string $response cURL HTTP response
+	 */
+	private function fetchMessageBody($response)
+	{
+		preg_match("/(?:\r\n){2}(.*)$/ms", $response, $match);
+		$this->messageBody = $match[1];
+	}
 
-    /**
-     * @param string $response cURL HTTP response
-     *
-     * @return bool Whether the Content-Type header was found or not
-     */
-    protected function fetchContentType($response)
-    {
-        if (0 < preg_match("/Content-Type:(\V*)/ims", $response, $match)) {
-            $this->contentType = trim($match[1]);
+	/**
+	 * @param string $response cURL HTTP response
+	 *
+	 * @return bool Whether the Content-Type header was found or not
+	 */
+	protected function fetchContentType($response)
+	{
+		if (0 < preg_match("/Content-Type:(\V*)/ims", $response, $match)) {
+			$this->contentType = trim($match[1]);
 
-            return true;
-        }
+			return true;
+		}
 
-        return false;
-    }
+		return false;
+	}
 }