Merge branch 'release/0.0.22'

Author: cwacek

python_jsonschema_objects/classbuilder.py

@@ -464,10 +464,14 @@ def _construct(self, uri, clsdata, parent=(ProtocolBase,)):
             return self.resolved[uri]
 
         elif clsdata.get('type') == 'array' and 'items' in clsdata:
-            self.resolved[uri] = self._build_object(
+            clsdata_copy = {}
+            clsdata_copy.update(clsdata)
+            self.resolved[uri] = validators.ArrayValidator.create(
                 uri,
-                clsdata,
-                parent)
+                item_constraint=clsdata_copy.pop('items'),
+                classbuilder=self,
+                **clsdata_copy)
+            return self.resolved[uri]
 
         elif (clsdata.get('type', None) == 'object' or
               clsdata.get('properties', None) is not None or
@@ -700,12 +704,12 @@ def setprop(self, val):
                 type_checks.append(typ)
                 continue
               typ = ProtocolBase.__SCHEMA_TYPES__[typ['type']]
-              if typ == None:
-                typ = type(None)
+              if typ is None:
+                  typ = type(None)
               if isinstance(typ, (list, tuple)):
-                type_checks.extend(typ)
+                  type_checks.extend(typ)
               else:
-                type_checks.append(typ)
+                  type_checks.append(typ)
 
             for typ in type_checks:
                 if isinstance(val, typ):
@@ -734,6 +738,17 @@ def setprop(self, val):
                         val.validate()
                         ok = True
                         break
+                elif util.safe_issubclass(typ, validators.ArrayValidator):
+                    try:
+                        val = typ(val)
+                    except Exception as e:
+                        errors.append(
+                            "Failed to coerce to '{0}': {1}".format(typ, e))
+                        pass
+                    else:
+                        val.validate()
+                        ok = True
+                        break
 
             if not ok:
                 errstr = "\n".join(errors)
@@ -754,6 +769,12 @@ def setprop(self, val):
                 val = info['type'](**util.coerce_for_expansion(val))
 
             val.validate()
+        elif info['type'] is None:
+            # This is the null value
+            if val is not None:
+                raise validators.ValidationError(
+                    "None is only valid value for null")
+        
         else:
             raise TypeError("Unknown object type: '{0}'".format(info['type']))
 

python_jsonschema_objects/validators.py

@@ -1,6 +1,8 @@
 import six
 from python_jsonschema_objects import util
 import collections
+import logging
+logger = logging.getLogger(__name__)
 
 
 class ValidationError(Exception):
@@ -156,7 +158,13 @@ def check_type(param, value, type_data):
 class ArrayValidator(object):
 
     def __init__(self, ary):
-        self.data = ary
+        if isinstance(ary, (list, tuple, collections.Sequence)):
+            self.data = ary
+        elif isinstance(ary, ArrayValidator):
+            self.data = ary.data
+        else:
+            raise TypeError("Invalid value given to array validator: {0}"
+                            .format(ary))
 
     def validate(self):
         converted = self.validate_items()
@@ -261,6 +269,7 @@ def create(name, item_constraint=None, **addl_constraints):
         constraints permitted by JSON Schema v4.
         """
         from python_jsonschema_objects import classbuilder
+        klassbuilder = addl_constraints.pop("classbuilder", None)
         props = {}
 
         if item_constraint is not None:
@@ -283,7 +292,29 @@ def create(name, item_constraint=None, **addl_constraints):
                 if not any([isdict, isklass]):
                     raise TypeError("Item constraint is not a schema")
 
-                if isdict and item_constraint['type'] == 'array':
+                if isdict and '$ref' in item_constraint:
+                    if klassbuilder is None:
+                        raise TypeError("Cannot resolve {0} without classbuilder"
+                                        .format(item_constraint['$ref']))
+
+                    uri = item_constraint['$ref']
+                    if uri in klassbuilder.resolved:
+                        logger.debug(util.lazy_format(
+                            "Using previously resolved object for {0}", uri))
+                    else:
+                        logger.debug(util.lazy_format("Resolving object for {0}", uri))
+
+                        with klassbuilder.resolver.resolving(uri) as resolved:
+                            # Set incase there is a circular reference in schema definition
+                            klassbuilder.resolved[uri] = None
+                            klassbuilder.resolved[uri] = klassbuilder.construct(
+                                uri,
+                                resolved,
+                                (classbuilder.ProtocolBase,))
+
+                    item_constraint = klassbuilder.resolved[uri]
+
+                elif isdict and item_constraint['type'] == 'array':
                     item_constraint = ArrayValidator.create(name + "#sub",
                                                             item_constraint=item_constraint[
                                                                 'items'],

test/test_pytest.py

@@ -5,6 +5,9 @@
 import pkg_resources
 import python_jsonschema_objects as pjs
 
+import logging
+logging.basicConfig(level=logging.DEBUG)
+
 
 def test_regression_9():
     schema = {
@@ -20,6 +23,42 @@ def test_regression_9():
     builder = pjs.ObjectBuilder(schema)
     builder.build_classes()
 
+def test_array_regressions():
+    schema = {
+        "$schema": "http://json-schema.org/schema#",
+        "id": "test",
+        "type": "object",
+        "properties": {
+                "name": {"type": "string"},
+                "email_aliases": {
+                    "type": "object",
+                    "additionalProperties": {
+                        "type": "array",
+                        "items": {"$ref": "#/definitions/foo"}
+                    }
+                }
+        },
+        "definitions": {
+            "foo": {
+                "type": "string"
+            }
+        }
+    }
+    builder = pjs.ObjectBuilder(schema)
+
+    ns = builder.build_classes()
+
+    x = ns.Test.from_json('''{"email_aliases": {
+            "Freddie": ["james", "bond"]
+            }}''')
+    x.validate()
+
+    y = ns.Test(email_aliases={
+        "Freddie": ["james", "bond"]
+    })
+    y.validate()
+
+
 def test_arrays_can_have_reffed_items_of_mixed_type():
     schema = {
             "$schema": "http://json-schema.org/schema#",