Implementation of ObjectTypes as Data.

Author: jhgg

epoxy/bases/__init__.py

@@ -0,0 +1 @@
+__author__ = 'jake'

epoxy/bases/object_type.py

@@ -0,0 +1,34 @@
+class ObjectTypeBase(object):
+    T = None
+    _field_attr_map = None
+
+    def __init__(self, **kwargs):
+        field_map_init = kwargs.pop('__field_map_init', False)
+        if field_map_init:
+            return
+
+        if self._field_attr_map is None:
+            raise RuntimeError("You cannot construct type {} until it is used in a created Schema.".format(
+                self.T
+            ))
+
+        # Todo: Maybe some type checking? Probably not tho.
+        for field_name in self._field_attr_map.keys():
+            if field_name in kwargs:
+                setattr(self, field_name, kwargs.pop(field_name))
+
+            else:
+                setattr(self, field_name, None)
+
+        if kwargs:
+            raise TypeError('Type {} received unexpected keyword argument(s): {}.'.format(
+                self.T,
+                ', '.join(kwargs.keys())
+            ))
+
+    def __repr__(self):
+        return '<{} {}>'.format(
+            self.T,
+            ' '.join('{}={!r}'.format(field_name, getattr(self, field_name))
+                     for field_name in self._field_attr_map.keys())
+        )

epoxy/metaclasses/interface.py

@@ -1,7 +1,9 @@
 from collections import OrderedDict
+from functools import partial
 from graphql.core.type.definition import GraphQLInterfaceType
 from ..utils.get_declared_fields import get_declared_fields
 from ..utils.make_default_resolver import make_default_resolver
+from ..utils.ref_holder import RefHolder
 from ..utils.yank_potential_fields import yank_potential_fields
 
 
@@ -10,18 +12,21 @@ def __new__(mcs, name, bases, attrs):
         if attrs.get('abstract'):
             return super(InterfaceMeta, mcs).__new__(mcs, name, bases, attrs)
 
+        class_ref = RefHolder()
         declared_fields = get_declared_fields(name, yank_potential_fields(attrs))
         interface = GraphQLInterfaceType(
             name,
-            fields=lambda: mcs._build_field_map(attrs, declared_fields),
+            fields=partial(mcs._build_field_map, class_ref, declared_fields),
             description=attrs.get('__doc__'),
             resolve_type=lambda: None
         )
+
         mcs._register(interface, declared_fields)
-        attrs['T'] = interface
-        attrs['_registry'] = mcs._get_registry()
         cls = super(InterfaceMeta, mcs).__new__(mcs, name, bases, attrs)
-        attrs['_cls'] = cls
+        cls.T = interface
+        cls._registry = mcs._get_registry()
+        class_ref.set(cls)
+
         return cls
 
     @staticmethod
@@ -33,9 +38,13 @@ def _get_registry():
         raise NotImplementedError('_get_registry must be implemented in the sub-metaclass')
 
     @staticmethod
-    def _build_field_map(attrs, fields):
-        instance = attrs['_cls']()
-        registry = attrs['_registry']
+    def _build_field_map(class_ref, fields):
+        cls = class_ref.get()
+        if not cls:
+            return
+
+        instance = cls()
+        registry = cls._registry
 
         field_map = OrderedDict()
 

epoxy/metaclasses/object_type.py

@@ -1,30 +1,34 @@
 from collections import OrderedDict
+from functools import partial
 from graphql.core.type import GraphQLObjectType
 from ..utils.get_declared_fields import get_declared_fields
 from ..utils.make_default_resolver import make_default_resolver
 from ..utils.no_implementation_registration import no_implementation_registration
+from ..utils.ref_holder import RefHolder
 from ..utils.yank_potential_fields import yank_potential_fields
 
 
 class ObjectTypeMeta(type):
     def __new__(mcs, name, bases, attrs):
-        if attrs.get('abstract'):
+        if attrs.pop('abstract', False):
             return super(ObjectTypeMeta, mcs).__new__(mcs, name, bases, attrs)
 
+        class_ref = RefHolder()
         declared_fields = get_declared_fields(name, yank_potential_fields(attrs))
         with no_implementation_registration():
             object_type = GraphQLObjectType(
                 name,
-                fields=lambda: mcs._build_field_map(attrs, declared_fields),
+                fields=partial(mcs._build_field_map, class_ref, declared_fields),
                 description=attrs.get('__doc__'),
                 interfaces=mcs._get_interfaces()
             )
 
         mcs._register(object_type)
-        attrs['_registry'] = mcs._get_registry()
-        attrs['T'] = object_type
         cls = super(ObjectTypeMeta, mcs).__new__(mcs, name, bases, attrs)
-        attrs['_cls'] = cls
+        cls.T = object_type
+        cls._registry = mcs._get_registry()
+        class_ref.set(cls)
+
         return cls
 
     @staticmethod
@@ -36,10 +40,14 @@ def _get_registry():
         raise NotImplementedError('_get_registry must be implemented in the sub-metaclass')
 
     @staticmethod
-    def _build_field_map(attrs, declared_fields):
-        instance = attrs['_cls']()
-        type = attrs['T']
-        registry = attrs['_registry']
+    def _build_field_map(class_ref, declared_fields):
+        cls = class_ref.get()
+        if not cls:
+            return
+
+        instance = cls(__field_map_init=True)
+        type = cls.T
+        registry = cls._registry
         interfaces = type.get_interfaces()
         fields = []
 
@@ -54,6 +62,7 @@ def _build_field_map(attrs, declared_fields):
 
         fields += declared_fields
         field_map = OrderedDict()
+        field_attr_map = OrderedDict()
 
         for field_attr_name, field in fields:
             resolve_fn = (
@@ -70,8 +79,15 @@ def _build_field_map(attrs, declared_fields):
             if field.name in field_map:
                 del field_map[field.name]
 
-            field_map[field.name] = field.to_field(registry, resolve_fn)
+            graphql_field = field.to_field(registry, resolve_fn)
+            field_map[field.name] = graphql_field
+
+            if field_attr_name in field_attr_map:
+                del field_attr_map[field_attr_name]
+
+            field_attr_map[field_attr_name] = graphql_field
 
+        cls._field_attr_map = field_attr_map
         return field_map
 
     @staticmethod

epoxy/registry.py

@@ -18,6 +18,7 @@
 from graphql.core.type.schema import type_map_reducer
 
 import six
+from .bases.object_type import ObjectTypeBase
 from .field import Field
 from .metaclasses.interface import InterfaceMeta
 from .metaclasses.object_type import ObjectTypeMeta
@@ -116,7 +117,8 @@ def _get_interfaces():
 
                 return None
 
-        class ObjectType(six.with_metaclass(RegistryObjectTypeMeta)):
+        @six.add_metaclass(RegistryObjectTypeMeta)
+        class ObjectType(ObjectTypeBase):
             abstract = True
 
         return ObjectType

epoxy/utils/gen_id.py

@@ -4,7 +4,7 @@
 def gen_id():
     global _prev_id
 
-    next_id = _prev_id
     _prev_id += 1
+    next_id = _prev_id
 
     return next_id

epoxy/utils/ref_holder.py

@@ -0,0 +1,20 @@
+from weakref import ReferenceType, ref
+
+
+class RefHolder(object):
+    ref = None
+
+    def __init__(self, ref=None):
+        if ref is not None:
+            self.set(ref)
+
+    def _delete_ref(self, ref):
+        if ref is self.ref:
+            self.ref = None
+
+    def get(self):
+        if isinstance(self.ref, ReferenceType):
+            return self.ref()
+
+    def set(self, item):
+        self.ref = ref(item, self._delete_ref)

tests/test_declarative_definition.py

@@ -161,3 +161,20 @@ class Dog(R.Interface):
             friend_aliased = R.Field(R.Dog, name='friend')
 
     assert str(excinfo.value) == 'Duplicate field definition for name "friend" in type "Dog.friend_aliased".'
+
+
+def test_orders_fields_in_order_declared():
+    R = TypeRegistry()
+
+    class Dog(R.ObjectType):
+        id = R.ID
+        name = R.Field('String')
+        dog = R.Dog
+        some_other_field = R.Field(R.Int)
+        some_other_dog = R.Field('Dog')
+        foo = R.String
+        bar = R.String
+        aaa = R.String
+
+    field_order = list(Dog.T.get_fields().keys())
+    assert field_order == ['id', 'name', 'dog', 'someOtherField', 'someOtherDog', 'foo', 'bar', 'aaa']

tests/test_object_type_as_data.py

@@ -0,0 +1,42 @@
+from graphql.core import graphql
+from epoxy.registry import TypeRegistry
+from pytest import raises
+
+R = TypeRegistry()
+
+
+class Human(R.ObjectType):
+    name = R.String
+    favorite_color = R.String
+
+
+Schema = R.schema(R.Human)
+
+
+def test_object_type_as_data():
+    jake = Human(name='Jake', favorite_color='Red')
+    assert jake.name == 'Jake'
+    assert jake.favorite_color == 'Red'
+    assert repr(jake) == '<Human name={!r} favorite_color={!r}>'.format(jake.name, jake.favorite_color)
+
+    result = graphql(Schema, '{ name favoriteColor }', jake)
+    assert not result.errors
+    assert result.data == {'name': 'Jake', 'favoriteColor': 'Red'}
+
+
+def test_object_type_as_data_with_partial_fields_provided():
+    jake = Human(name='Jake')
+    assert jake.name == 'Jake'
+    assert jake.favorite_color is None
+    assert repr(jake) == '<Human name={!r} favorite_color={!r}>'.format(jake.name, jake.favorite_color)
+
+    result = graphql(Schema, '{ name favoriteColor }', jake)
+    assert not result.errors
+    assert result.data == {'name': 'Jake', 'favoriteColor': None}
+
+
+def test_object_type_giving_unexpected_key():
+    with raises(TypeError) as excinfo:
+        Human(after_all=True)
+
+    assert str(excinfo.value) == 'Type Human received unexpected keyword argument(s): after_all.'

tox.ini

@@ -10,7 +10,7 @@ deps =
     py{py,27,33}: enum34
     py{py,27,33,34}: singledispatch
 commands =
-    py{py,27,33,34,35}: py.test --cov {envsitepackagesdir}/epoxy tests
+    py{py,27,33,34,35}: py.test --cov {envsitepackagesdir}/epoxy tests {posargs}
 
 
 [testenv:flake8]