Improvements to type coercion (#384)

* Improve performance - don't loop over everything if already valid

* Don't coerce already-valid types (fixes #379)

* Add remaining coercion cases & rewrite tests

 * Add all remaining coercion cases from ajv matrix
 * Rewrite the coercion tests to tidy things up a bit

* Add CHECK_MODE_EARLY_COERCE

If set, falls back to the old behavior of coercing to the first
compatible type, regardless of whether another already-valid type might
be available.

* Add multiple-type test that requires coercion

* \JSON_PRETTY_PRINT doesn't exist in PHP-5.3, so work around this

* Various PR cleanup stuff

 * Fix whitespace
 * Turn $early into $extraFlags
 * Change "string" to "ABC" in string test
 * Update README.md description of CHECK_MODE_EARLY_COERCE

* Move loop after complex tests definition

* Move test #39 to grid #15

Author: erayd

README.md

@@ -186,14 +186,19 @@ third argument to `Validator::validate()`, or can be provided as the third argum
 | `Constraint::CHECK_MODE_NORMAL` | Validate in 'normal' mode - this is the default |
 | `Constraint::CHECK_MODE_TYPE_CAST` | Enable fuzzy type checking for associative arrays and objects |
 | `Constraint::CHECK_MODE_COERCE_TYPES` | Convert data types to match the schema where possible |
+| `Constraint::CHECK_MODE_EARLY_COERCE` | Apply type coercion as soon as possible |
 | `Constraint::CHECK_MODE_APPLY_DEFAULTS` | Apply default values from the schema if not set |
 | `Constraint::CHECK_MODE_ONLY_REQUIRED_DEFAULTS` | When applying defaults, only set values that are required |
 | `Constraint::CHECK_MODE_EXCEPTIONS` | Throw an exception immediately if validation fails |
 | `Constraint::CHECK_MODE_DISABLE_FORMAT` | Do not validate "format" constraints |
 | `Constraint::CHECK_MODE_VALIDATE_SCHEMA` | Validate the schema as well as the provided document |
 
-Please note that using `Constraint::CHECK_MODE_COERCE_TYPES` or `Constraint::CHECK_MODE_APPLY_DEFAULTS`
-will modify your original data.
+Please note that using `CHECK_MODE_COERCE_TYPES` or `CHECK_MODE_APPLY_DEFAULTS` will modify your
+original data.
+
+`CHECK_MODE_EARLY_COERCE` has no effect unless used in combination with `CHECK_MODE_COERCE_TYPES`. If
+enabled, the validator will use (and coerce) the first compatible type it encounters, even if the
+schema defines another type that matches directly and does not require coercion.
 
 ## Running the tests
 

src/JsonSchema/Constraints/Constraint.php

@@ -31,6 +31,7 @@ abstract class Constraint extends BaseConstraint implements ConstraintInterface
     const CHECK_MODE_APPLY_DEFAULTS =   0x00000008;
     const CHECK_MODE_EXCEPTIONS =       0x00000010;
     const CHECK_MODE_DISABLE_FORMAT =   0x00000020;
+    const CHECK_MODE_EARLY_COERCE =     0x00000040;
     const CHECK_MODE_ONLY_REQUIRED_DEFAULTS   = 0x00000080;
     const CHECK_MODE_VALIDATE_SCHEMA =  0x00000100;
 

src/JsonSchema/Constraints/TypeConstraint.php

@@ -44,16 +44,24 @@ public function check(&$value = null, $schema = null, JsonPointer $path = null,
     {
         $type = isset($schema->type) ? $schema->type : null;
         $isValid = false;
+        $coerce = $this->factory->getConfig(self::CHECK_MODE_COERCE_TYPES);
+        $earlyCoerce = $this->factory->getConfig(self::CHECK_MODE_EARLY_COERCE);
         $wording = array();
 
         if (is_array($type)) {
-            $this->validateTypesArray($value, $type, $wording, $isValid, $path);
+            $this->validateTypesArray($value, $type, $wording, $isValid, $path, $coerce && $earlyCoerce);
+            if (!$isValid && $coerce && !$earlyCoerce) {
+                $this->validateTypesArray($value, $type, $wording, $isValid, $path, true);
+            }
         } elseif (is_object($type)) {
             $this->checkUndefined($value, $type, $path);
 
             return;
         } else {
-            $isValid = $this->validateType($value, $type);
+            $isValid = $this->validateType($value, $type, $coerce && $earlyCoerce);
+            if (!$isValid && $coerce && !$earlyCoerce) {
+                $isValid = $this->validateType($value, $type, true);
+            }
         }
 
         if ($isValid === false) {
@@ -62,8 +70,8 @@ public function check(&$value = null, $schema = null, JsonPointer $path = null,
                 $wording[] = self::$wording[$type];
             }
             $this->addError(ConstraintError::TYPE(), $path, array(
-                    'expected' => gettype($value),
-                    'found' => $this->implodeWith($wording, ', ', 'or')
+                    'found' => gettype($value),
+                    'expected' => $this->implodeWith($wording, ', ', 'or')
             ));
         }
     }
@@ -79,9 +87,14 @@ public function check(&$value = null, $schema = null, JsonPointer $path = null,
      * @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, $coerce = false)
     {
         foreach ($type as $tp) {
+            // already valid, so no need to waste cycles looping over everything
+            if ($isValid) {
+                return;
+            }
+
             // $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)) {
@@ -98,7 +111,7 @@ protected function validateTypesArray(&$value, array $type, &$validTypesWording,
                 $this->validateTypeNameWording($tp);
                 $validTypesWording[] = self::$wording[$tp];
                 if (!$isValid) {
-                    $isValid = $this->validateType($value, $tp);
+                    $isValid = $this->validateType($value, $tp, $coerce);
                 }
             }
         }
@@ -157,7 +170,7 @@ protected function validateTypeNameWording($type)
      *
      * @return bool
      */
-    protected function validateType(&$value, $type)
+    protected function validateType(&$value, $type, $coerce = false)
     {
         //mostly the case for inline schema
         if (!$type) {
@@ -173,11 +186,13 @@ protected function validateType(&$value, $type)
         }
 
         if ('array' === $type) {
+            if ($coerce) {
+                $value = $this->toArray($value);
+            }
+
             return $this->getTypeCheck()->isArray($value);
         }
 
-        $coerce = $this->factory->getConfig(Constraint::CHECK_MODE_COERCE_TYPES);
-
         if ('integer' === $type) {
             if ($coerce) {
                 $value = $this->toInteger($value);
@@ -203,10 +218,18 @@ protected function validateType(&$value, $type)
         }
 
         if ('string' === $type) {
+            if ($coerce) {
+                $value = $this->toString($value);
+            }
+
             return is_string($value);
         }
 
         if ('null' === $type) {
+            if ($coerce) {
+                $value = $this->toNull($value);
+            }
+
             return is_null($value);
         }
 
@@ -222,19 +245,21 @@ protected function validateType(&$value, $type)
      */
     protected function toBoolean($value)
     {
-        if ($value === 'true') {
+        if ($value === 1 || $value === 'true') {
             return true;
         }
-
-        if ($value === 'false') {
+        if (is_null($value) || $value === 0 || $value === 'false') {
             return false;
         }
+        if ($this->getTypeCheck()->isArray($value) && count($value) === 1) {
+            return $this->toBoolean(reset($value));
+        }
 
         return $value;
     }
 
     /**
-     * Converts a numeric string to a number. For example, "4" becomes 4.
+     * Converts a value to a number. For example, "4.5" becomes 4.5.
      *
      * @param mixed $value the value to convert to a number
      *
@@ -245,14 +270,89 @@ protected function toNumber($value)
         if (is_numeric($value)) {
             return $value + 0; // cast to number
         }
+        if (is_bool($value) || is_null($value)) {
+            return (int) $value;
+        }
+        if ($this->getTypeCheck()->isArray($value) && count($value) === 1) {
+            return $this->toNumber(reset($value));
+        }
 
         return $value;
     }
 
+    /**
+     * Converts a value to an integer. For example, "4" becomes 4.
+     *
+     * @param mixed $value
+     *
+     * @return int|mixed
+     */
     protected function toInteger($value)
     {
-        if (is_numeric($value) && (int) $value == $value) {
-            return (int) $value; // cast to number
+        $numberValue = $this->toNumber($value);
+        if (is_numeric($numberValue) && (int) $numberValue == $numberValue) {
+            return (int) $numberValue; // cast to number
+        }
+
+        return $value;
+    }
+
+    /**
+     * Converts a value to an array containing that value. For example, [4] becomes 4.
+     *
+     * @param mixed $value
+     *
+     * @return array|mixed
+     */
+    protected function toArray($value)
+    {
+        if (is_scalar($value) || is_null($value)) {
+            return array($value);
+        }
+
+        return $value;
+    }
+
+    /**
+     * Convert a value to a string representation of that value. For example, null becomes "".
+     *
+     * @param mixed $value
+     *
+     * @return string|mixed
+     */
+    protected function toString($value)
+    {
+        if (is_numeric($value)) {
+            return "$value";
+        }
+        if ($value === true) {
+            return 'true';
+        }
+        if ($value === false) {
+            return 'false';
+        }
+        if (is_null($value)) {
+            return '';
+        }
+        if ($this->getTypeCheck()->isArray($value) && count($value) === 1) {
+            return $this->toString(reset($value));
+        }
+    }
+
+    /**
+     * Convert a value to a null. For example, 0 becomes null.
+     *
+     * @param mixed $value
+     *
+     * @return null|mixed
+     */
+    protected function toNull($value)
+    {
+        if ($value === 0 || $value === false || $value === '') {
+            return null;
+        }
+        if ($this->getTypeCheck()->isArray($value) && count($value) === 1) {
+            return $this->toNull(reset($value));
         }
 
         return $value;