Allow specification of default values to the Schema.from_dict function (#42)

* Allow specification of default values to the Schema.from_dict function

When using the from_dict method, you might be in a situation where you
want every Schema created to have a certain property, like "inclusion":
"automatic". This allows you to do that like:

```python
Schema.from_dict(dict_, inclusion="automatic")
```

* Add test that confirms overriding from_dict options happens

Author: b-ryan

setup.py

@@ -78,18 +78,22 @@ def to_dict(self):
         return result
 
     @classmethod
-    def from_dict(cls, data):
-        '''Initialize a Schema object based on the JSON Schema structure.'''
-        kwargs = {}
+    def from_dict(cls, data, **schema_defaults):
+        '''Initialize a Schema object based on the JSON Schema structure.
+
+        :param schema_defaults: The default values to the Schema
+        constructor.'''
+        kwargs = schema_defaults.copy()
         properties = data.get('properties')
         items = data.get('items')
 
         if properties:
             kwargs['properties'] = {
-                k: Schema.from_dict(v) for k, v in properties.items()
+                k: Schema.from_dict(v, **schema_defaults)
+                for k, v in properties.items()
             }
         if items:
-            kwargs['items'] = Schema.from_dict(items)
+            kwargs['items'] = Schema.from_dict(items, **schema_defaults)
         for key in STANDARD_KEYS:
             if key in data:
                 kwargs[key] = data[key]

singer/schema.py

@@ -25,7 +25,8 @@ class TestSchema(unittest.TestCase):
         'properties': {
             'a_string': string_dict,
             'an_array': array_dict
-        }
+        },
+        'inclusion': 'whatever',
     }
 
     # Schema object forms of the same schemas as above
@@ -37,7 +38,8 @@ class TestSchema(unittest.TestCase):
 
     object_obj = Schema(type='object',
                         properties={'a_string': string_obj,
-                                    'an_array': array_obj})
+                                    'an_array': array_obj},
+                        inclusion='whatever')
 
     def test_string_to_dict(self):
         self.assertEquals(self.string_dict, self.string_obj.to_dict())
@@ -49,23 +51,29 @@ def test_array_to_dict(self):
         self.assertEquals(self.array_dict, self.array_obj.to_dict())
 
     def test_object_to_dict(self):
-        self.assertEquals(self.object_dict, self.object_obj.to_dict())        
+        self.assertEquals(self.object_dict, self.object_obj.to_dict())
 
     def test_string_from_dict(self):
         self.assertEquals(self.string_obj, Schema.from_dict(self.string_dict))
 
     def test_integer_from_dict(self):
         self.assertEquals(self.integer_obj, Schema.from_dict(self.integer_dict))
 
-    def test_array_from_dict(self):        
+    def test_array_from_dict(self):
         self.assertEquals(self.array_obj, Schema.from_dict(self.array_dict))
 
-    def test_object_from_dict(self):        
-        self.assertEquals(self.object_obj, Schema.from_dict(self.object_dict))        
-                
+    def test_object_from_dict(self):
+        self.assertEquals(self.object_obj, Schema.from_dict(self.object_dict))
+
     def test_repr_atomic(self):
         self.assertEquals(self.string_obj, eval(repr(self.string_obj)))
 
     def test_repr_recursive(self):
         self.assertEquals(self.object_obj, eval(repr(self.object_obj)))
 
+    def test_object_from_dict_with_defaults(self):
+        schema = Schema.from_dict(self.object_dict, inclusion='automatic')
+        self.assertEquals('whatever', schema.inclusion,
+                          msg='The schema value should override the default')
+        self.assertEquals('automatic', schema.properties['a_string'].inclusion)
+        self.assertEquals('automatic', schema.properties['an_array'].items.inclusion)