gravityview / GravityView

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

Spacing +50 added lines, -50 removed lines

@@ -21,15 +21,15 @@ 
 {
     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;
+    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
@@ -39,18 +39,18 @@ 
      *
      * @return JsonPointer;
      */
-    protected function incrementPath(JsonPointer $path = null, $i)
+    protected function incrementPath( JsonPointer $path = null, $i )
     {
-        $path = $path ?: new JsonPointer('');
+        $path = $path ?: new JsonPointer( '' );
 
-        if ($i === null || $i === '') {
+        if ( $i === null || $i === '' ) {
             return $path;
         }
 
         $path = $path->withPropertyPaths(
             array_merge(
                 $path->getPropertyPaths(),
-                array($i)
+                array( $i )
             )
         );
 
@@ -65,12 +65,12 @@ 
      * @param JsonPointer|null $path
      * @param mixed            $i
      */
-    protected function checkArray(&$value, $schema = null, JsonPointer $path = null, $i = null)
+    protected function checkArray( &$value, $schema = null, JsonPointer $path = null, $i = null )
     {
-        $validator = $this->factory->createInstanceFor('collection');
-        $validator->check($value, $schema, $path, $i);
+        $validator = $this->factory->createInstanceFor( 'collection' );
+        $validator->check( $value, $schema, $path, $i );
 
-        $this->addErrors($validator->getErrors());
+        $this->addErrors( $validator->getErrors() );
     }
 
     /**
@@ -83,13 +83,13 @@ 
      * @param mixed            $additionalProperties
      * @param mixed            $patternProperties
      */
-    protected function checkObject(&$value, $schema = null, JsonPointer $path = null, $properties = null,
-        $additionalProperties = null, $patternProperties = null, $appliedDefaults = array())
+    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);
+        $validator = $this->factory->createInstanceFor( 'object' );
+        $validator->check( $value, $schema, $path, $properties, $additionalProperties, $patternProperties, $appliedDefaults );
 
-        $this->addErrors($validator->getErrors());
+        $this->addErrors( $validator->getErrors() );
     }
 
     /**
@@ -100,12 +100,12 @@ 
      * @param JsonPointer|null $path
      * @param mixed            $i
      */
-    protected function checkType(&$value, $schema = null, JsonPointer $path = null, $i = null)
+    protected function checkType( &$value, $schema = null, JsonPointer $path = null, $i = null )
     {
-        $validator = $this->factory->createInstanceFor('type');
-        $validator->check($value, $schema, $path, $i);
+        $validator = $this->factory->createInstanceFor( 'type' );
+        $validator->check( $value, $schema, $path, $i );
 
-        $this->addErrors($validator->getErrors());
+        $this->addErrors( $validator->getErrors() );
     }
 
     /**
@@ -116,13 +116,13 @@ 
      * @param JsonPointer|null $path
      * @param mixed            $i
      */
-    protected function checkUndefined(&$value, $schema = null, JsonPointer $path = null, $i = null, $fromDefault = false)
+    protected function checkUndefined( &$value, $schema = null, JsonPointer $path = null, $i = null, $fromDefault = false )
     {
-        $validator = $this->factory->createInstanceFor('undefined');
+        $validator = $this->factory->createInstanceFor( 'undefined' );
 
-        $validator->check($value, $this->factory->getSchemaStorage()->resolveRefSchema($schema), $path, $i, $fromDefault);
+        $validator->check( $value, $this->factory->getSchemaStorage()->resolveRefSchema( $schema ), $path, $i, $fromDefault );
 
-        $this->addErrors($validator->getErrors());
+        $this->addErrors( $validator->getErrors() );
     }
 
     /**
@@ -133,12 +133,12 @@ 
      * @param JsonPointer|null $path
      * @param mixed            $i
      */
-    protected function checkString($value, $schema = null, JsonPointer $path = null, $i = null)
+    protected function checkString( $value, $schema = null, JsonPointer $path = null, $i = null )
     {
-        $validator = $this->factory->createInstanceFor('string');
-        $validator->check($value, $schema, $path, $i);
+        $validator = $this->factory->createInstanceFor( 'string' );
+        $validator->check( $value, $schema, $path, $i );
 
-        $this->addErrors($validator->getErrors());
+        $this->addErrors( $validator->getErrors() );
     }
 
     /**
@@ -149,12 +149,12 @@ 
      * @param JsonPointer $path
      * @param mixed       $i
      */
-    protected function checkNumber($value, $schema = null, JsonPointer $path = null, $i = null)
+    protected function checkNumber( $value, $schema = null, JsonPointer $path = null, $i = null )
     {
-        $validator = $this->factory->createInstanceFor('number');
-        $validator->check($value, $schema, $path, $i);
+        $validator = $this->factory->createInstanceFor( 'number' );
+        $validator->check( $value, $schema, $path, $i );
 
-        $this->addErrors($validator->getErrors());
+        $this->addErrors( $validator->getErrors() );
     }
 
     /**
@@ -165,12 +165,12 @@ 
      * @param JsonPointer|null $path
      * @param mixed            $i
      */
-    protected function checkEnum($value, $schema = null, JsonPointer $path = null, $i = null)
+    protected function checkEnum( $value, $schema = null, JsonPointer $path = null, $i = null )
     {
-        $validator = $this->factory->createInstanceFor('enum');
-        $validator->check($value, $schema, $path, $i);
+        $validator = $this->factory->createInstanceFor( 'enum' );
+        $validator->check( $value, $schema, $path, $i );
 
-        $this->addErrors($validator->getErrors());
+        $this->addErrors( $validator->getErrors() );
     }
 
     /**
@@ -181,12 +181,12 @@ 
      * @param JsonPointer|null $path
      * @param mixed            $i
      */
-    protected function checkFormat($value, $schema = null, JsonPointer $path = null, $i = null)
+    protected function checkFormat( $value, $schema = null, JsonPointer $path = null, $i = null )
     {
-        $validator = $this->factory->createInstanceFor('format');
-        $validator->check($value, $schema, $path, $i);
+        $validator = $this->factory->createInstanceFor( 'format' );
+        $validator->check( $value, $schema, $path, $i );
 
-        $this->addErrors($validator->getErrors());
+        $this->addErrors( $validator->getErrors() );
     }
 
     /**
@@ -204,15 +204,15 @@ 
      *
      * @return string property path
      */
-    protected function convertJsonPointerIntoPropertyPath(JsonPointer $pointer)
+    protected function convertJsonPointerIntoPropertyPath( JsonPointer $pointer )
     {
         $result = array_map(
-            function ($path) {
-                return sprintf(is_numeric($path) ? '[%d]' : '.%s', $path);
+            function( $path ) {
+                return sprintf( is_numeric( $path ) ? '[%d]' : '.%s', $path );
             },
             $pointer->getPropertyPaths()
         );
 
-        return trim(implode('', $result), '.');
+        return trim( implode( '', $result ), '.' );
     }
 }

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

Spacing +12 added lines, -12 removed lines

@@ -22,33 +22,33 @@
     /**
      * {@inheritdoc}
      */
-    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    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)) {
+        if ( $element instanceof UndefinedConstraint && ( ! isset( $schema->required ) || ! $schema->required ) ) {
             return;
         }
-        $type = gettype($element);
+        $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) {
+        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) {
+            if ( $type === gettype( $enum ) ) {
+                if ( $type == 'object' ) {
+                    if ( $element == $enum ) {
                         return;
                     }
-                } elseif ($element === $enum) {
+                } 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

Spacing +71 added lines, -71 removed lines

@@ -39,29 +39,29 @@ 
     /**
      * {@inheritdoc}
      */
-    public function check(&$value = null, $schema = null, JsonPointer $path = null, $i = null)
+    public function check( &$value = null, $schema = null, JsonPointer $path = null, $i = null )
     {
-        $type = isset($schema->type) ? $schema->type : 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);
+        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);
+            $isValid = $this->validateType( $value, $type );
         }
 
-        if ($isValid === false) {
-            if (!is_array($type)) {
-                $this->validateTypeNameWording($type);
-                $wording[] = self::$wording[$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');
+            $this->addError( $path, ucwords( gettype( $value ) ) . ' value found, but ' .
+                $this->implodeWith( $wording, ', ', 'or' ) . ' is required', 'type' );
         }
     }
 
@@ -76,26 +76,26 @@ 
      * @param bool  $isValid           The current validation value
      * @param $path
      */
-    protected function validateTypesArray(&$value, array $type, &$validTypesWording, &$isValid, $path)
+    protected function validateTypesArray( &$value, array $type, &$validTypesWording, &$isValid, $path )
     {
-        foreach ($type as $tp) {
+        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');
+            if ( is_object( $tp ) ) {
+                if ( ! $isValid ) {
+                    $validator = $this->factory->createInstanceFor( 'type' );
                     $subSchema = new \stdClass();
                     $subSchema->type = $tp;
-                    $validator->check($value, $subSchema, $path, null);
+                    $validator->check( $value, $subSchema, $path, null );
                     $error = $validator->getErrors();
-                    $isValid = !(bool) $error;
-                    $validTypesWording[] = self::$wording['object'];
+                    $isValid = ! (bool)$error;
+                    $validTypesWording[ ] = self::$wording[ 'object' ];
                 }
             } else {
-                $this->validateTypeNameWording($tp);
-                $validTypesWording[] = self::$wording[$tp];
-                if (!$isValid) {
-                    $isValid = $this->validateType($value, $tp);
+                $this->validateTypeNameWording( $tp );
+                $validTypesWording[ ] = self::$wording[ $tp ];
+                if ( ! $isValid ) {
+                    $isValid = $this->validateType( $value, $tp );
                 }
             }
         }
@@ -112,16 +112,16 @@ 
      *
      * @return string
      */
-    protected function implodeWith(array $elements, $delimiter = ', ', $listEnd = false)
+    protected function implodeWith( array $elements, $delimiter = ', ', $listEnd = false )
     {
-        if ($listEnd === false || !isset($elements[1])) {
-            return implode($delimiter, $elements);
+        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);
+        $lastElement  = array_slice( $elements, -1 );
+        $firsElements = join( $delimiter, array_slice( $elements, 0, -1 ) );
+        $implodedElements = array_merge( array( $firsElements ), $lastElement );
 
-        return join(" $listEnd ", $implodedElements);
+        return join( " $listEnd ", $implodedElements );
     }
 
     /**
@@ -132,14 +132,14 @@ 
      *
      * @throws StandardUnexpectedValueException
      */
-    protected function validateTypeNameWording($type)
+    protected function validateTypeNameWording( $type )
     {
-        if (!isset(self::$wording[$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)))
+                    var_export( $type, true ),
+                    implode( ', ', array_filter( self::$wording ) ))
             );
         }
     }
@@ -154,64 +154,64 @@ 
      *
      * @return bool
      */
-    protected function validateType(&$value, $type)
+    protected function validateType( &$value, $type )
     {
         //mostly the case for inline schema
-        if (!$type) {
+        if ( ! $type ) {
             return true;
         }
 
-        if ('any' === $type) {
+        if ( 'any' === $type ) {
             return true;
         }
 
-        if ('object' === $type) {
-            return $this->getTypeCheck()->isObject($value);
+        if ( 'object' === $type ) {
+            return $this->getTypeCheck()->isObject( $value );
         }
 
-        if ('array' === $type) {
-            return $this->getTypeCheck()->isArray($value);
+        if ( 'array' === $type ) {
+            return $this->getTypeCheck()->isArray( $value );
         }
 
-        $coerce = $this->factory->getConfig(Constraint::CHECK_MODE_COERCE_TYPES);
+        $coerce = $this->factory->getConfig( Constraint::CHECK_MODE_COERCE_TYPES );
 
-        if ('integer' === $type) {
-            if ($coerce) {
-                $value = $this->toInteger($value);
+        if ( 'integer' === $type ) {
+            if ( $coerce ) {
+                $value = $this->toInteger( $value );
             }
 
-            return is_int($value);
+            return is_int( $value );
         }
 
-        if ('number' === $type) {
-            if ($coerce) {
-                $value = $this->toNumber($value);
+        if ( 'number' === $type ) {
+            if ( $coerce ) {
+                $value = $this->toNumber( $value );
             }
 
-            return is_numeric($value) && !is_string($value);
+            return is_numeric( $value ) && ! is_string( $value );
         }
 
-        if ('boolean' === $type) {
-            if ($coerce) {
-                $value = $this->toBoolean($value);
+        if ( 'boolean' === $type ) {
+            if ( $coerce ) {
+                $value = $this->toBoolean( $value );
             }
 
-            return is_bool($value);
+            return is_bool( $value );
         }
 
-        if ('string' === $type) {
-            return is_string($value);
+        if ( 'string' === $type ) {
+            return is_string( $value );
         }
 
-        if ('email' === $type) {
-            return is_string($value);
+        if ( 'email' === $type ) {
+            return is_string( $value );
         }
 
-        if ('null' === $type) {
-            return is_null($value);
+        if ( 'null' === $type ) {
+            return is_null( $value );
         }
 
-        throw new InvalidArgumentException((is_object($value) ? 'object' : $value) . ' is an invalid type for ' . $type);
+        throw new InvalidArgumentException( ( is_object( $value ) ? 'object' : $value ) . ' is an invalid type for ' . $type );
     }
 
     /**
@@ -221,13 +221,13 @@ 
      *
      * @return bool|mixed
      */
-    protected function toBoolean($value)
+    protected function toBoolean( $value )
     {
-        if ($value === 'true') {
+        if ( $value === 'true' ) {
             return true;
         }
 
-        if ($value === 'false') {
+        if ( $value === 'false' ) {
             return false;
         }
 
@@ -241,19 +241,19 @@ 
      *
      * @return int|float|mixed
      */
-    protected function toNumber($value)
+    protected function toNumber( $value )
     {
-        if (is_numeric($value)) {
+        if ( is_numeric( $value ) ) {
             return $value + 0; // cast to number
         }
 
         return $value;
     }
 
-    protected function toInteger($value)
+    protected function toInteger( $value )
     {
-        if (is_numeric($value) && (int) $value == $value) {
-            return (int) $value; // cast to number
+        if ( is_numeric( $value ) && (int)$value == $value ) {
+            return (int)$value; // cast to number
         }
 
         return $value;

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

Spacing +125 added lines, -125 removed lines

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

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

Spacing +26 added lines, -26 removed lines

@@ -22,54 +22,54 @@
     /**
      * {@inheritdoc}
      */
-    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    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));
+        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');
+                $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));
+        } 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));
+        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');
+                $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));
+        } 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));
+        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));
+        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)
+    private function fmod( $number1, $number2 )
     {
-        $modulus = ($number1 - round($number1 / $number2) * $number2);
+        $modulus = ( $number1 - round( $number1 / $number2 ) * $number2 );
         $precision = 0.0000000001;
 
         if (-$precision < $modulus && $modulus < $precision) {

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

Spacing +61 added lines, -61 removed lines

@@ -24,121 +24,121 @@ 
     /**
      * {@inheritdoc}
      */
-    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    public function check( &$element, $schema = null, JsonPointer $path = null, $i = null )
     {
-        if (!isset($schema->format) || $this->factory->getConfig(self::CHECK_MODE_DISABLE_FORMAT)) {
+        if ( ! isset( $schema->format ) || $this->factory->getConfig( self::CHECK_MODE_DISABLE_FORMAT ) ) {
             return;
         }
 
-        switch ($schema->format) {
+        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));
+                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));
+                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));
+                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));
+                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));
+                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));
+                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));
+                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));
+                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));
+                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)) {
+                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) {
+                    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);
+                            $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));
+                    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')) {
+                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
+                    $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));
+                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));
+                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));
+                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));
+                if ( ! $this->validateHostname( $element ) ) {
+                    $this->addError( $path, 'Invalid hostname', 'format', array( 'format' => $schema->format ) );
                 }
                 break;
 
@@ -153,15 +153,15 @@ 
         }
     }
 
-    protected function validateDateTime($datetime, $format)
+    protected function validateDateTime( $datetime, $format )
     {
-        $dt = \DateTime::createFromFormat($format, $datetime);
+        $dt = \DateTime::createFromFormat( $format, $datetime );
 
-        if (!$dt) {
+        if ( ! $dt ) {
             return false;
         }
 
-        if ($datetime === $dt->format($format)) {
+        if ( $datetime === $dt->format( $format ) ) {
             return true;
         }
 
@@ -169,46 +169,46 @@ 
         // 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))) {
+        if ( ( strpos( 'u', $format ) !== -1 ) && ( preg_match( '/\.\d+Z$/', $datetime ) ) ) {
             return true;
         }
 
         return false;
     }
 
-    protected function validateRegex($regex)
+    protected function validateRegex( $regex )
     {
-        return false !== @preg_match('/' . $regex . '/u', '');
+        return false !== @preg_match( '/' . $regex . '/u', '' );
     }
 
-    protected function validateColor($color)
+    protected function validateColor( $color )
     {
-        if (in_array(strtolower($color), array('aqua', 'black', 'blue', 'fuchsia',
+        if ( in_array( strtolower( $color ), array( 'aqua', 'black', 'blue', 'fuchsia',
             'gray', 'green', 'lime', 'maroon', 'navy', 'olive', 'orange', 'purple',
-            'red', 'silver', 'teal', 'white', 'yellow'))) {
+            'red', 'silver', 'teal', 'white', 'yellow' ) ) ) {
             return true;
         }
 
-        return preg_match('/^#([a-f0-9]{3}|[a-f0-9]{6})$/i', $color);
+        return preg_match( '/^#([a-f0-9]{3}|[a-f0-9]{6})$/i', $color );
     }
 
-    protected function validateStyle($style)
+    protected function validateStyle( $style )
     {
-        $properties     = explode(';', rtrim($style, ';'));
-        $invalidEntries = preg_grep('/^\s*[-a-z]+\s*:\s*.+$/i', $properties, PREG_GREP_INVERT);
+        $properties     = explode( ';', rtrim( $style, ';' ) );
+        $invalidEntries = preg_grep( '/^\s*[-a-z]+\s*:\s*.+$/i', $properties, PREG_GREP_INVERT );
 
-        return empty($invalidEntries);
+        return empty( $invalidEntries );
     }
 
-    protected function validatePhone($phone)
+    protected function validatePhone( $phone )
     {
-        return preg_match('/^\+?(\(\d{3}\)|\d{3}) \d{3} \d{4}$/', $phone);
+        return preg_match( '/^\+?(\(\d{3}\)|\d{3}) \d{3} \d{4}$/', $phone );
     }
 
-    protected function validateHostname($host)
+    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);
+        return preg_match( $hostnameRegex, $host );
     }
 }

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

Spacing +15 added lines, -15 removed lines

@@ -22,39 +22,39 @@
     /**
      * {@inheritdoc}
      */
-    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    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(
+        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(
+        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(
+        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);
+        $this->checkFormat( $element, $schema, $path, $i );
     }
 
-    private function strlen($string)
+    private function strlen( $string )
     {
-        if (extension_loaded('mbstring')) {
-            return mb_strlen($string, mb_detect_encoding($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
+        return strlen( $string ); // @codeCoverageIgnore
     }
 }

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

Spacing +26 added lines, -26 removed lines

@@ -28,67 +28,67 @@
     /**
      * {@inheritdoc}
      */
-    public function check(&$element, $schema = null, JsonPointer $path = null, $i = null)
+    public function check( &$element, $schema = null, JsonPointer $path = null, $i = null )
     {
-        if ($schema !== null) {
+        if ( $schema !== null ) {
             // passed schema
             $validationSchema = $schema;
-        } elseif ($this->getTypeCheck()->propertyExists($element, $this->inlineSchemaProperty)) {
+        } elseif ( $this->getTypeCheck()->propertyExists( $element, $this->inlineSchemaProperty ) ) {
             // inline schema
-            $validationSchema = $this->getTypeCheck()->propertyGet($element, $this->inlineSchemaProperty);
+            $validationSchema = $this->getTypeCheck()->propertyGet( $element, $this->inlineSchemaProperty );
         } else {
-            throw new InvalidArgumentException('no schema found to verify against');
+            throw new InvalidArgumentException( 'no schema found to verify against' );
         }
 
         // cast array schemas to object
-        if (is_array($validationSchema)) {
-            $validationSchema = BaseConstraint::arrayToObjectRecursive($validationSchema);
+        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->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');
+            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);
+            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);
+            $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);
+                $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');
+            if ( $this->numErrors() > $initialErrorCount ) {
+                $this->addError( $path, 'Schema is not valid', 'schema' );
             }
 
             // restore the initial config
-            $this->factory->setConfig($initialConfig);
-            $this->factory->setErrorContext($initialContext);
+            $this->factory->setConfig( $initialConfig );
+            $this->factory->setErrorContext( $initialContext );
         }
 
         // validate element against $validationSchema
-        $this->checkUndefined($element, $validationSchema, $path, $i);
+        $this->checkUndefined( $element, $validationSchema, $path, $i );
     }
 }

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

Spacing +54 added lines, -54 removed lines

@@ -27,52 +27,52 @@ 
     /**
      * {@inheritdoc}
      */
-    public function check(&$element, $schema = null, JsonPointer $path = null, $properties = null,
-        $additionalProp = null, $patternProperties = null, $appliedDefaults = array())
+    public function check( &$element, $schema = null, JsonPointer $path = null, $properties = null,
+        $additionalProp = null, $patternProperties = null, $appliedDefaults = array() )
     {
-        if ($element instanceof UndefinedConstraint) {
+        if ( $element instanceof UndefinedConstraint ) {
             return;
         }
 
         $this->appliedDefaults = $appliedDefaults;
 
         $matches = array();
-        if ($patternProperties) {
+        if ( $patternProperties ) {
             // validate the element pattern properties
-            $matches = $this->validatePatternProperties($element, $path, $patternProperties);
+            $matches = $this->validatePatternProperties( $element, $path, $patternProperties );
         }
 
-        if ($properties) {
+        if ( $properties ) {
             // validate the element properties
-            $this->validateProperties($element, $properties, $path);
+            $this->validateProperties( $element, $properties, $path );
         }
 
         // validate additional element properties & constraints
-        $this->validateElement($element, $matches, $schema, $path, $properties, $additionalProp);
+        $this->validateElement( $element, $matches, $schema, $path, $properties, $additionalProp );
     }
 
-    public function validatePatternProperties($element, JsonPointer $path = null, $patternProperties)
+    public function validatePatternProperties( $element, JsonPointer $path = null, $patternProperties )
     {
-        $try = array('/', '#', '+', '~', '%');
+        $try = array( '/', '#', '+', '~', '%' );
         $matches = array();
-        foreach ($patternProperties as $pregex => $schema) {
+        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
+            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));
+            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));
+            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 ) );
                 }
             }
         }
@@ -90,37 +90,37 @@ 
      * @param \StdClass        $properties     Properties
      * @param mixed            $additionalProp Additional properties
      */
-    public function validateElement($element, $matches, $schema = null, JsonPointer $path = null,
-        $properties = null, $additionalProp = null)
+    public function validateElement( $element, $matches, $schema = null, JsonPointer $path = null,
+        $properties = null, $additionalProp = null )
     {
-        $this->validateMinMaxConstraint($element, $schema, $path);
+        $this->validateMinMaxConstraint( $element, $schema, $path );
 
-        foreach ($element as $i => $value) {
-            $definition = $this->getProperty($properties, $i);
+        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');
+            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));
+            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));
+                    $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');
+            $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);
+            $property = $this->getProperty( $element, $i, $this->factory->createInstanceFor( 'undefined' ) );
+            if ( is_object( $property ) ) {
+                $this->validateMinMaxConstraint( ! ( $property instanceof UndefinedConstraint ) ? $property : $element, $definition, $path );
             }
         }
     }
@@ -132,17 +132,17 @@ 
      * @param \stdClass        $properties Property definitions
      * @param JsonPointer|null $path       Path?
      */
-    public function validateProperties(&$element, $properties = null, JsonPointer $path = null)
+    public function validateProperties( &$element, $properties = null, JsonPointer $path = null )
     {
-        $undefinedConstraint = $this->factory->createInstanceFor('undefined');
+        $undefinedConstraint = $this->factory->createInstanceFor( 'undefined' );
 
-        foreach ($properties as $i => $value) {
-            $property = &$this->getProperty($element, $i, $undefinedConstraint);
-            $definition = $this->getProperty($properties, $i);
+        foreach ( $properties as $i => $value ) {
+            $property = &$this->getProperty( $element, $i, $undefinedConstraint );
+            $definition = $this->getProperty( $properties, $i );
 
-            if (is_object($definition)) {
+            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));
+                $this->checkUndefined( $property, $definition, $path, $i, in_array( $i, $this->appliedDefaults ) );
             }
         }
     }
@@ -156,11 +156,11 @@ 
      *
      * @return mixed
      */
-    protected function &getProperty(&$element, $property, $fallback = null)
+    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)) {
+        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;
         }
 
@@ -174,18 +174,18 @@ 
      * @param \stdClass        $objectDefinition ObjectConstraint definition
      * @param JsonPointer|null $path             Path to test?
      */
-    protected function validateMinMaxConstraint($element, $objectDefinition, JsonPointer $path = null)
+    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));
+        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));
+        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 ) );
             }
         }
     }