Support json_decode assoc

src/JsonSchema/Constraints/CollectionConstraint.php

@@ -76,7 +76,7 @@ protected function validateItems($value, $schema = null, $path = null, $i = null
                 // Reset errors if needed
                 if (isset($secondErrors) && count($secondErrors) < count($this->getErrors())) {
                     $this->errors = $secondErrors;
-                } else if (isset($secondErrors) && count($secondErrors) === count($this->getErrors())) {
+                } elseif (isset($secondErrors) && count($secondErrors) === count($this->getErrors())) {
                     $this->errors = $initErrors;
                 }
             }
@@ -102,7 +102,7 @@ protected function validateItems($value, $schema = null, $path = null, $i = null
             }
 
             // Treat when we have more schema definitions than values, not for empty arrays
-            if(count($value) > 0) {
+            if (count($value) > 0) {
                 for ($k = count($value); $k < count($schema->items); $k++) {
                     $this->checkUndefined(new UndefinedConstraint(), $schema->items[$k], $path, $k);
                 }

src/JsonSchema/Constraints/Constraint.php

@@ -10,6 +10,7 @@
 namespace JsonSchema\Constraints;
 
 use JsonSchema\Uri\UriRetriever;
+use JsonSchema\Validator;
 
 /**
  * The Base Constraints, all Validators should extend this class
@@ -49,8 +50,7 @@ public function __construct($checkMode = self::CHECK_MODE_NORMAL, UriRetriever $
      */
     public function getUriRetriever()
     {
-        if (is_null($this->uriRetriever))
-        {
+        if (is_null($this->uriRetriever)) {
             $this->setUriRetriever(new UriRetriever);
         }
 
@@ -63,7 +63,7 @@ public function getUriRetriever()
     public function getFactory()
     {
         if (!$this->factory) {
-            $this->factory = new Factory($this->getUriRetriever());
+            $this->factory = new Factory($this->getUriRetriever(), $this->checkMode);
         }
 
         return $this->factory;
@@ -288,4 +288,14 @@ protected function retrieveUri($uri)
         // TODO validate using schema
         return $jsonSchema;
     }
+
+    /**
+     * Get the type check based on the set check mode.
+     *
+     * @return TypeCheck\TypeCheckInterface
+     */
+    protected function getTypeCheck()
+    {
+        return $this->getFactory()->getTypeCheck();
+    }
 }

src/JsonSchema/Constraints/EnumConstraint.php

@@ -8,6 +8,7 @@
  */
 
 namespace JsonSchema\Constraints;
+use JsonSchema\Validator;
 
 /**
  * The EnumConstraint Constraints, validates an element against a given set of possibilities
@@ -26,17 +27,23 @@ public function check($element, $schema = null, $path = null, $i = null)
         if ($element instanceof UndefinedConstraint && (!isset($schema->required) || !$schema->required)) {
             return;
         }
+        $type = gettype($element);
 
         foreach ($schema->enum as $enum) {
-            $type = gettype($element);
+            $enumType = gettype($enum);
+            if ($this->checkMode === 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 ($element == $enum) {
                         return;
-                } else {
-                    if ($element === $enum)
-                        return;
-
+                    }
+                } elseif ($element === $enum) {
+                    return;
                 }
             }
         }

src/JsonSchema/Constraints/Factory.php

@@ -11,7 +11,6 @@
 
 use JsonSchema\Exception\InvalidArgumentException;
 use JsonSchema\Uri\UriRetriever;
-use JsonSchema\Validator;
 
 /**
  * Factory for centralize constraint initialization.
@@ -23,6 +22,16 @@ class Factory
      */
     protected $uriRetriever;
 
+    /**
+     * @var int
+     */
+    private $checkMode;
+
+    /**
+     * @var TypeCheck\TypeCheckInterface[]
+     */
+    private $typeCheck = array();
+
     /**
      * @var array $constraintMap
      */
@@ -43,13 +52,14 @@ class Factory
     /**
      * @param UriRetriever $uriRetriever
      */
-    public function __construct(UriRetriever $uriRetriever = null)
+    public function __construct(UriRetriever $uriRetriever = null, $checkMode = Constraint::CHECK_MODE_NORMAL)
     {
         if (!$uriRetriever) {
             $uriRetriever = new UriRetriever();
         }
 
         $this->uriRetriever = $uriRetriever;
+        $this->checkMode = $checkMode;
     }
 
     /**
@@ -60,23 +70,36 @@ public function getUriRetriever()
         return $this->uriRetriever;
     }
 
+    public function getTypeCheck()
+    {
+        if (!isset($this->typeCheck[$this->checkMode])) {
+            if ($this->checkMode === Constraint::CHECK_MODE_TYPE_CAST) {
+                $this->typeCheck[Constraint::CHECK_MODE_TYPE_CAST] = new TypeCheck\LooseTypeCheck();
+            } else {
+                $this->typeCheck[$this->checkMode] = new TypeCheck\StrictTypeCheck();
+            }
+        }
+
+        return $this->typeCheck[$this->checkMode];
+    }
+
     /**
      * @param string $name
      * @param string $class
      * @return Factory
      */
     public function setConstraintClass($name, $class)
     {
-      // Ensure class exists
-      if (!class_exists($class)) {
-        throw new InvalidArgumentException('Unknown constraint ' . $name);
-      }
-      // Ensure class is appropriate
-      if (!in_array('JsonSchema\Constraints\ConstraintInterface', class_implements($class))) {
-        throw new InvalidArgumentException('Invalid class ' . $name);
-      }
-      $this->constraintMap[$name] = $class;
-      return $this;
+        // Ensure class exists
+        if (!class_exists($class)) {
+            throw new InvalidArgumentException('Unknown constraint ' . $name);
+        }
+        // Ensure class is appropriate
+        if (!in_array('JsonSchema\Constraints\ConstraintInterface', class_implements($class))) {
+            throw new InvalidArgumentException('Invalid class ' . $name);
+        }
+        $this->constraintMap[$name] = $class;
+        return $this;
     }
 
     /**
@@ -89,7 +112,7 @@ public function setConstraintClass($name, $class)
     public function createInstanceFor($constraintName)
     {
         if (array_key_exists($constraintName, $this->constraintMap)) {
-          return new $this->constraintMap[$constraintName](Constraint::CHECK_MODE_NORMAL, $this->uriRetriever, $this);
+            return new $this->constraintMap[$constraintName]($this->checkMode, $this->uriRetriever, $this);
         }
         throw new InvalidArgumentException('Unknown constraint ' . $constraintName);
     }

src/JsonSchema/Constraints/NumberConstraint.php

@@ -27,13 +27,13 @@ public function check($element, $schema = null, $path = null, $i = null)
             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,));
-                } else if ($element < $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');
             }
-        } else if (isset($schema->minimum) && $element < $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,));
         }
 
@@ -42,13 +42,13 @@ public function check($element, $schema = null, $path = null, $i = null)
             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,));
-                } else if ($element > $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');
             }
-        } else if (isset($schema->maximum) && $element > $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,));
         }
 

src/JsonSchema/Constraints/ObjectConstraint.php

@@ -20,7 +20,7 @@ class ObjectConstraint extends Constraint
     /**
      * {@inheritDoc}
      */
-    function check($element, $definition = null, $path = null, $additionalProp = null, $patternProperties = null)
+    public function check($element, $definition = null, $path = null, $additionalProp = null, $patternProperties = null)
     {
         if ($element instanceof UndefinedConstraint) {
             return;
@@ -161,13 +161,13 @@ protected function getProperty($element, $property, $fallback = null)
     protected function validateMinMaxConstraint($element, $objectDefinition, $path) {
         // Verify minimum number of properties
         if (isset($objectDefinition->minProperties) && !is_object($objectDefinition->minProperties)) {
-            if (count(get_object_vars($element)) < $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 (count(get_object_vars($element)) > $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,));
             }
         }

src/JsonSchema/Constraints/SchemaConstraint.php

@@ -27,11 +27,16 @@ public function check($element, $schema = null, $path = null, $i = null)
         if ($schema !== null) {
             // passed schema
             $this->checkUndefined($element, $schema, '', '');
-        } elseif (property_exists($element, $this->inlineSchemaProperty)) {
+        } elseif ($this->getTypeCheck()->propertyExists($element, $this->inlineSchemaProperty)) {
+            $inlineSchema = $this->getTypeCheck()->propertyGet($element, $this->inlineSchemaProperty);
+            if (is_array($inlineSchema)) {
+                $inlineSchema = json_decode(json_encode($inlineSchema));
+            }
+
             // inline schema
-            $this->checkUndefined($element, $element->{$this->inlineSchemaProperty}, '', '');
+            $this->checkUndefined($element, $inlineSchema, '', '');
         } else {
             throw new InvalidArgumentException('no schema found to verify against');
         }
     }
-}
+}

src/JsonSchema/Constraints/TypeCheck/LooseTypeCheck.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace JsonSchema\Constraints\TypeCheck;
+
+class LooseTypeCheck implements TypeCheckInterface
+{
+    public static function isObject($value)
+    {
+        return
+            is_object($value) ||
+            (is_array($value) && (count($value) == 0 || self::isAssociativeArray($value)));
+    }
+
+    public static function isArray($value)
+    {
+        return
+            is_array($value) &&
+            (count($value) == 0 || !self::isAssociativeArray($value));
+    }
+
+    public static function propertyGet($value, $property)
+    {
+        if (is_object($value)) {
+            return $value->{$property};
+        }
+
+        return $value[$property];
+    }
+
+    public static function propertyExists($value, $property)
+    {
+        if (is_object($value)) {
+            return property_exists($value, $property);
+        }
+
+        return array_key_exists($property, $value);
+    }
+
+    public static function propertyCount($value)
+    {
+        if (is_object($value)) {
+            return count(get_object_vars($value));
+        }
+
+        return count($value);
+    }
+
+    /**
+     * Check if the provided array is associative or not
+     *
+     * @param array $arr
+     *
+     * @return bool
+     */
+    private static function isAssociativeArray($arr)
+    {
+        return (array_keys($arr) !== range(0, count($arr) - 1));
+    }
+}

src/JsonSchema/Constraints/TypeCheck/StrictTypeCheck.php

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

src/JsonSchema/Constraints/TypeCheck/TypeCheckInterface.php

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

src/JsonSchema/Constraints/TypeConstraint.php

@@ -116,12 +116,11 @@ protected function validateType($value, $type)
         }
 
         if ('object' === $type) {
-            return is_object($value);
-            //return ($this::CHECK_MODE_TYPE_CAST == $this->checkMode) ? is_array($value) : is_object($value);
+            return $this->getTypeCheck()->isObject($value);
         }
 
         if ('array' === $type) {
-            return is_array($value);
+            return $this->getTypeCheck()->isArray($value);
         }
 
         if ('string' === $type) {