Merge branch 'refs/heads/features/plugins-autocamelcase' into features/django-debug

Author: syrusakbary

graphene/contrib/django/fields.py

@@ -27,7 +27,7 @@ def internal_type(self, schema):
         if not field_object_type:
             raise SkipField()
         if is_node(field_object_type):
-            field = DjangoConnectionField(field_object_type)
+            field = ConnectionField(field_object_type)
         else:
             field = Field(List(field_object_type))
         field.contribute_to_class(self.object_type, self.attname)

graphene/contrib/django/utils.py

@@ -1,5 +1,8 @@
 from django.db import models
 from django.db.models.manager import Manager
+from django.db.models.query import QuerySet
+
+from graphene.utils import LazyList
 
 
 def get_type_for_model(schema, model):
@@ -19,7 +22,18 @@ def get_reverse_fields(model):
             yield related
 
 
+class WrappedQueryset(LazyList):
+
+    def __len__(self):
+        # Dont calculate the length using len(queryset), as this will
+        # evaluate the whole queryset and return it's length.
+        # Use .count() instead
+        return self._origin.count()
+
+
 def maybe_queryset(value):
     if isinstance(value, Manager):
         value = value.get_queryset()
+    if isinstance(value, QuerySet):
+        return WrappedQueryset(value)
     return value

graphene/core/classtypes/base.py

@@ -1,10 +1,10 @@
 import copy
 import inspect
+from functools import partial
 from collections import OrderedDict
 
 import six
 
-from ..exceptions import SkipField
 from .options import Options
 
 
@@ -48,8 +48,8 @@ def construct(cls, bases, attrs):
 
         if not cls._meta.abstract:
             from ..types import List, NonNull
-            setattr(cls, 'NonNull', NonNull(cls))
-            setattr(cls, 'List', List(cls))
+            setattr(cls, 'NonNull', partial(NonNull, cls))
+            setattr(cls, 'List', partial(List, cls))
 
         return cls
 
@@ -81,31 +81,36 @@ def fields(self):
     def fields_map(self):
         return OrderedDict([(f.attname, f) for f in self.fields])
 
+    @property
+    def fields_group_type(self):
+        from ..types.field import FieldsGroupType
+        return FieldsGroupType(*self.local_fields)
+
 
 class FieldsClassTypeMeta(ClassTypeMeta):
     options_class = FieldsOptions
 
     def extend_fields(cls, bases):
         new_fields = cls._meta.local_fields
-        field_names = {f.name: f for f in new_fields}
+        field_names = {f.attname: f for f in new_fields}
 
         for base in bases:
             if not isinstance(base, FieldsClassTypeMeta):
                 continue
 
             parent_fields = base._meta.local_fields
             for field in parent_fields:
-                if field.name in field_names and field.type.__class__ != field_names[
-                        field.name].type.__class__:
+                if field.attname in field_names and field.type.__class__ != field_names[
+                        field.attname].type.__class__:
                     raise Exception(
                         'Local field %r in class %r (%r) clashes '
                         'with field with similar name from '
                         'Interface %s (%r)' % (
-                            field.name,
+                            field.attname,
                             cls.__name__,
                             field.__class__,
                             base.__name__,
-                            field_names[field.name].__class__)
+                            field_names[field.attname].__class__)
                     )
                 new_field = copy.copy(field)
                 cls.add_to_class(field.attname, new_field)
@@ -123,11 +128,4 @@ class Meta:
 
     @classmethod
     def fields_internal_types(cls, schema):
-        fields = []
-        for field in cls._meta.fields:
-            try:
-                fields.append((field.name, schema.T(field)))
-            except SkipField:
-                continue
-
-        return OrderedDict(fields)
+        return schema.T(cls._meta.fields_group_type)

graphene/core/classtypes/tests/test_base.py

@@ -23,15 +23,26 @@ class Meta:
 def test_classtype_definition_list():
     class Character(ClassType):
         '''Character description'''
-    assert isinstance(Character.List, List)
-    assert Character.List.of_type == Character
+    assert isinstance(Character.List(), List)
+    assert Character.List().of_type == Character
 
 
 def test_classtype_definition_nonnull():
     class Character(ClassType):
         '''Character description'''
-    assert isinstance(Character.NonNull, NonNull)
-    assert Character.NonNull.of_type == Character
+    assert isinstance(Character.NonNull(), NonNull)
+    assert Character.NonNull().of_type == Character
+
+
+def test_fieldsclasstype_definition_order():
+    class Character(ClassType):
+        '''Character description'''
+
+    class Query(FieldsClassType):
+        name = String()
+        char = Character.NonNull()
+
+    assert list(Query._meta.fields_map.keys()) == ['name', 'char']
 
 
 def test_fieldsclasstype():

graphene/core/classtypes/tests/test_mutation.py

@@ -24,4 +24,4 @@ class Input:
     assert list(object_type.get_fields().keys()) == ['name']
     assert MyMutation._meta.fields_map['name'].object_type == MyMutation
     assert isinstance(MyMutation.arguments, ArgumentsGroup)
-    assert 'argName' in MyMutation.arguments
+    assert 'argName' in schema.T(MyMutation.arguments)

graphene/core/schema.py

@@ -12,6 +12,7 @@
 
 from .classtypes.base import ClassType
 from .types.base import BaseType
+from ..plugins import Plugin, CamelCase
 
 
 class GraphQLSchema(_GraphQLSchema):
@@ -25,27 +26,43 @@ class Schema(object):
     _executor = None
 
     def __init__(self, query=None, mutation=None, subscription=None,
-                 name='Schema', executor=None):
+                 name='Schema', executor=None, plugins=None, auto_camelcase=True):
         self._types_names = {}
         self._types = {}
         self.mutation = mutation
         self.query = query
         self.subscription = subscription
         self.name = name
         self.executor = executor
+        self.plugins = []
+        plugins = plugins or []
+        if auto_camelcase:
+            plugins.append(CamelCase())
+        for plugin in plugins:
+            self.add_plugin(plugin)
         signals.init_schema.send(self)
 
     def __repr__(self):
         return '<Schema: %s (%s)>' % (str(self.name), hash(self))
 
+    def add_plugin(self, plugin):
+        assert isinstance(plugin, Plugin), 'A plugin need to subclass graphene.Plugin and be instantiated'
+        plugin.contribute_to_schema(self)
+        self.plugins.append(plugin)
+
+    def get_internal_type(self, objecttype):
+        for plugin in self.plugins:
+            objecttype = plugin.transform_type(objecttype)
+        return objecttype.internal_type(self)
+
     def T(self, object_type):
         if not object_type:
             return
         if inspect.isclass(object_type) and issubclass(
                 object_type, (BaseType, ClassType)) or isinstance(
                 object_type, BaseType):
             if object_type not in self._types:
-                internal_type = object_type.internal_type(self)
+                internal_type = self.get_internal_type(object_type)
                 self._types[object_type] = internal_type
                 is_objecttype = inspect.isclass(
                     object_type) and issubclass(object_type, ClassType)

graphene/core/tests/test_old_fields.py

@@ -34,10 +34,11 @@ def test_field_type():
     assert schema.T(f).type == GraphQLString
 
 
-def test_field_name_automatic_camelcase():
+def test_field_name():
     f = Field(GraphQLString)
     f.contribute_to_class(MyOt, 'field_name')
-    assert f.name == 'fieldName'
+    assert f.name is None
+    assert f.attname == 'field_name'
 
 
 def test_field_name_use_name_if_exists():

graphene/core/types/argument.py

@@ -1,19 +1,19 @@
-from collections import OrderedDict
 from functools import wraps
 from itertools import chain
 
 from graphql.core.type import GraphQLArgument
 
-from ...utils import ProxySnakeDict, to_camel_case
-from .base import ArgumentType, BaseType, OrderedType
+from ...utils import ProxySnakeDict
+from .base import ArgumentType, GroupNamedType, NamedType, OrderedType
 
 
-class Argument(OrderedType):
+class Argument(NamedType, OrderedType):
 
     def __init__(self, type, description=None, default=None,
                  name=None, _creation_counter=None):
         super(Argument, self).__init__(_creation_counter=_creation_counter)
         self.name = name
+        self.attname = None
         self.type = type
         self.description = description
         self.default = default
@@ -27,47 +27,32 @@ def __repr__(self):
         return self.name
 
 
-class ArgumentsGroup(BaseType):
+class ArgumentsGroup(GroupNamedType):
 
     def __init__(self, *args, **kwargs):
         arguments = to_arguments(*args, **kwargs)
-        self.arguments = OrderedDict([(arg.name, arg) for arg in arguments])
-
-    def internal_type(self, schema):
-        return OrderedDict([(arg.name, schema.T(arg))
-                            for arg in self.arguments.values()])
-
-    def __len__(self):
-        return len(self.arguments)
-
-    def __iter__(self):
-        return iter(self.arguments)
-
-    def __contains__(self, *args):
-        return self.arguments.__contains__(*args)
-
-    def __getitem__(self, *args):
-        return self.arguments.__getitem__(*args)
+        super(ArgumentsGroup, self).__init__(*arguments)
 
 
 def to_arguments(*args, **kwargs):
     arguments = {}
     iter_arguments = chain(kwargs.items(), [(None, a) for a in args])
 
-    for name, arg in iter_arguments:
+    for attname, arg in iter_arguments:
         if isinstance(arg, Argument):
             argument = arg
         elif isinstance(arg, ArgumentType):
             argument = arg.as_argument()
         else:
-            raise ValueError('Unknown argument %s=%r' % (name, arg))
-
-        if name:
-            argument.name = to_camel_case(name)
-        assert argument.name, 'Argument in field must have a name'
-        assert argument.name not in arguments, 'Found more than one Argument with same name {}'.format(
-            argument.name)
-        arguments[argument.name] = argument
+            raise ValueError('Unknown argument %s=%r' % (attname, arg))
+
+        if attname:
+            argument.attname = attname
+
+        name = argument.name or argument.attname
+        assert name, 'Argument in field must have a name'
+        assert name not in arguments, 'Found more than one Argument with same name {}'.format(name)
+        arguments[name] = argument
 
     return sorted(arguments.values())
 

graphene/core/types/base.py

@@ -1,7 +1,10 @@
-from functools import total_ordering
+from collections import OrderedDict
+from functools import total_ordering, partial
 
 import six
 
+from ...utils import to_camel_case
+
 
 class BaseType(object):
 
@@ -126,3 +129,31 @@ def as_inputfield(self):
 
 class MountedType(FieldType, ArgumentType):
     pass
+
+
+class NamedType(BaseType):
+    pass
+
+
+class GroupNamedType(BaseType):
+    def __init__(self, *types):
+        self.types = types
+
+    def get_named_type(self, schema, type):
+        name = type.name or type.attname
+        return name, schema.T(type)
+
+    def internal_type(self, schema):
+        return OrderedDict(map(partial(self.get_named_type, schema), self.types))
+
+    def __len__(self):
+        return len(self.types)
+
+    def __iter__(self):
+        return iter(self.types)
+
+    def __contains__(self, *args):
+        return self.types.__contains__(*args)
+
+    def __getitem__(self, *args):
+        return self.types.__getitem__(*args)