Implement scalar type class definition.

Author: jhgg

epoxy/bases/scalar.py

@@ -0,0 +1,2 @@
+class ScalarBase(object):
+    pass

epoxy/metaclasses/scalar.py

@@ -0,0 +1,32 @@
+from graphql.core.type import GraphQLScalarType
+
+
+class ScalarMeta(type):
+    def __new__(mcs, name, bases, attrs):
+        if attrs.pop('abstract', False):
+            return super(ScalarMeta, mcs).__new__(mcs, name, bases, attrs)
+
+        registry = mcs._get_registry()
+
+        cls = super(ScalarMeta, mcs).__new__(mcs, name, bases, attrs)
+        cls._registry = registry
+        instance = cls()
+        serialize = getattr(instance, 'serialize')
+        parse_literal = getattr(instance, 'parse_literal')
+        parse_value = getattr(instance, 'parse_value')
+
+        mcs._register(GraphQLScalarType(
+            name=name,
+            description=attrs.get('__doc__', None),
+            serialize=serialize,
+            parse_value=parse_value,
+            parse_literal=parse_literal
+        ))
+
+    @staticmethod
+    def _register(mutation):
+        raise NotImplementedError('_register must be implemented in the sub-metaclass')
+
+    @staticmethod
+    def _get_registry():
+        raise NotImplementedError('_get_registry must be implemented in the sub-metaclass')

epoxy/registry.py

@@ -22,11 +22,13 @@
 from .bases.input_type import InputTypeBase
 from .bases.mutation import MutationBase
 from .bases.object_type import ObjectTypeBase
+from .bases.scalar import ScalarBase
 from .field import Field, InputField
 from .metaclasses.input_type import InputTypeMeta
 from .metaclasses.interface import InterfaceMeta
 from .metaclasses.mutation import MutationMeta
 from .metaclasses.object_type import ObjectTypeMeta
+from .metaclasses.scalar import ScalarMeta
 from .metaclasses.union import UnionMeta
 from .thunk import AttributeTypeThunk, RootTypeThunk, ThunkList, TransformThunkList
 from .utils.enum_to_graphql_enum import enum_to_graphql_enum
@@ -45,7 +47,7 @@
 class TypeRegistry(object):
     _reserved_names = frozenset([
         # Types
-        'ObjectType', 'InputType', 'Union' 'Interface', 'Implements',
+        'ObjectType', 'InputType', 'Union' 'Interface', 'Implements', 'Scalar'
         # Functions
         'Schema', 'Register', 'Mixin',
         # Mutations
@@ -71,6 +73,7 @@ def __init__(self):
         self.Union = ClassTypeCreator(self, self._create_union_type_class)
         self.Interface = self._create_interface_type_class()
         self.Mutation = self._create_mutation_type_class()
+        self.Scalar = self._create_scalar_type_class()
 
         for type in builtin_scalars:
             self.Register(type)
@@ -214,6 +217,24 @@ class InputType(InputTypeBase):
 
         return InputType
 
+    def _create_scalar_type_class(self):
+        registry = self
+
+        class RegistryScalarMeta(ScalarMeta):
+            @staticmethod
+            def _register(scalar):
+                registry.Register(scalar)
+
+            @staticmethod
+            def _get_registry():
+                return registry
+
+        @six.add_metaclass(RegistryScalarMeta)
+        class Scalar(ScalarBase):
+            abstract = True
+
+        return Scalar
+
     def _create_mutation_type_class(self):
         registry = self
 

tests/test_scalar.py

@@ -0,0 +1,122 @@
+import datetime
+from graphql.core import graphql
+from graphql.core.language import ast
+from graphql.core.type import GraphQLScalarType
+from epoxy.registry import TypeRegistry
+
+
+def test_custom_scalar_type():
+    R = TypeRegistry()
+
+    def serialize_date_time(dt):
+        assert isinstance(dt, datetime.datetime)
+        return dt.isoformat()
+
+    def parse_literal(node):
+        if isinstance(node, ast.StringValue):
+            return datetime.datetime.strptime(node.value, "%Y-%m-%dT%H:%M:%S.%f")
+
+    def parse_value(value):
+        return datetime.datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%f")
+
+    DateTimeType = GraphQLScalarType(name='DateTime', serialize=serialize_date_time,
+                                     parse_literal=parse_literal,
+                                     parse_value=parse_value)
+    R(DateTimeType)
+
+    class Query(R.ObjectType):
+        datetime = R.DateTime(args={
+            'in': R.DateTime
+        })
+
+        def resolve_datetime(self, obj, args, info):
+            return args.get('in')
+
+    now = datetime.datetime.now()
+    isoformat = now.isoformat()
+
+    Schema = R.Schema(R.Query)
+
+    response = graphql(Schema, '''
+        {
+            datetime(in: "%s")
+        }
+
+    ''' % isoformat)
+
+    assert not response.errors
+    assert response.data == {
+        'datetime': isoformat
+    }
+
+    response = graphql(Schema, '''
+        query Test($date: DateTime) {
+            datetime(in: $date)
+        }
+
+    ''', args={
+        'date': isoformat
+    })
+
+    assert not response.errors
+    assert response.data == {
+        'datetime': isoformat
+    }
+
+
+def test_register_scalar_type():
+    R = TypeRegistry()
+
+    class DateTime(R.Scalar):
+        @staticmethod
+        def serialize(dt):
+            assert isinstance(dt, datetime.datetime)
+            return dt.isoformat()
+
+        @staticmethod
+        def parse_literal(node):
+            if isinstance(node, ast.StringValue):
+                return datetime.datetime.strptime(node.value, "%Y-%m-%dT%H:%M:%S.%f")
+
+        @staticmethod
+        def parse_value(value):
+            return datetime.datetime.strptime(value, "%Y-%m-%dT%H:%M:%S.%f")
+
+    class Query(R.ObjectType):
+        datetime = R.DateTime(args={
+            'in': R.DateTime
+        })
+
+        def resolve_datetime(self, obj, args, info):
+            return args.get('in')
+
+    now = datetime.datetime.now()
+    isoformat = now.isoformat()
+
+    Schema = R.Schema(R.Query)
+
+    response = graphql(Schema, '''
+        {
+            datetime(in: "%s")
+        }
+
+    ''' % isoformat)
+
+    assert not response.errors
+    assert response.data == {
+        'datetime': isoformat
+    }
+
+    response = graphql(Schema, '''
+        query Test($date: DateTime) {
+            datetime(in: $date)
+        }
+
+    ''', args={
+        'date': isoformat
+    })
+
+    assert not response.errors
+    assert response.data == {
+        'datetime': isoformat
+    }

tests/test_starwars/test_query.py

@@ -1,6 +1,5 @@
 from .schema import StarWarsSchema
 from graphql.core import graphql
-from graphql.core.error import format_error
 
 
 def test_hero_name_query():