Merge remote-tracking branch 'upstream/master'

Author: faassen

graphql/core/execution/base.py

@@ -82,24 +82,31 @@ def __init__(self, data=None, errors=None, invalid=False):
                 error.value if isinstance(error, DeferredException) else error
                 for error in errors
             ]
+
         self.errors = errors
+
         if invalid:
             assert data is None
+
         self.invalid = invalid
 
 
 def get_operation_root_type(schema, operation):
     op = operation.operation
     if op == 'query':
         return schema.get_query_type()
+
     elif op == 'mutation':
         mutation_type = schema.get_mutation_type()
+
         if not mutation_type:
             raise GraphQLError(
                 'Schema is not configured for mutations',
                 [operation]
             )
+
         return mutation_type
+
     raise GraphQLError(
         'Can only execute queries and mutations',
         [operation]
@@ -109,35 +116,36 @@ def get_operation_root_type(schema, operation):
 def collect_fields(ctx, type, selection_set, fields, prev_fragment_names):
     for selection in selection_set.selections:
         directives = selection.directives
+
         if isinstance(selection, ast.Field):
             if not should_include_node(ctx, directives):
                 continue
+
             name = get_field_entry_key(selection)
-            if name not in fields:
-                fields[name] = []
             fields[name].append(selection)
+
         elif isinstance(selection, ast.InlineFragment):
-            if not should_include_node(ctx, directives) or \
-                    not does_fragment_condition_match(ctx, selection, type):
+            if not should_include_node(ctx, directives) or not does_fragment_condition_match(ctx, selection, type):
                 continue
-            collect_fields(
-                ctx, type, selection.selection_set,
-                fields, prev_fragment_names)
+
+            collect_fields(ctx, type, selection.selection_set, fields, prev_fragment_names)
+
         elif isinstance(selection, ast.FragmentSpread):
             frag_name = selection.name.value
-            if frag_name in prev_fragment_names or \
-                    not should_include_node(ctx, directives):
+
+            if frag_name in prev_fragment_names or not should_include_node(ctx, directives):
                 continue
+
             prev_fragment_names.add(frag_name)
             fragment = ctx.fragments.get(frag_name)
             frag_directives = fragment.directives
-            if not fragment or \
-                    not should_include_node(ctx, frag_directives) or \
-                    not does_fragment_condition_match(ctx, fragment, type):
+            if not fragment or not \
+                    should_include_node(ctx, frag_directives) or not \
+                    does_fragment_condition_match(ctx, fragment, type):
                 continue
-            collect_fields(
-                ctx, type, fragment.selection_set,
-                fields, prev_fragment_names)
+
+            collect_fields(ctx, type, fragment.selection_set, fields, prev_fragment_names)
+
     return fields
 
 
@@ -146,10 +154,12 @@ def should_include_node(ctx, directives):
     @skip directives, where @skip has higher precidence than @include."""
     if directives:
         skip_ast = None
+
         for directive in directives:
             if directive.name.value == GraphQLSkipDirective.name:
                 skip_ast = directive
                 break
+
         if skip_ast:
             args = get_argument_values(
                 GraphQLSkipDirective.args,
@@ -159,16 +169,19 @@ def should_include_node(ctx, directives):
             return not args.get('if')
 
         include_ast = None
+
         for directive in directives:
             if directive.name.value == GraphQLIncludeDirective.name:
                 include_ast = directive
                 break
+
         if include_ast:
             args = get_argument_values(
                 GraphQLIncludeDirective.args,
                 include_ast.arguments,
                 ctx.variables,
             )
+
             return bool(args.get('if'))
 
     return True

graphql/core/execution/executor.py

@@ -6,6 +6,7 @@
 from ..language import ast
 from ..language.parser import parse
 from ..language.source import Source
+from ..pyutils.default_ordered_dict import DefaultOrderedDict
 from ..type import GraphQLEnumType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, \
     GraphQLScalarType, GraphQLUnionType
 from ..validation import validate
@@ -75,9 +76,14 @@ def _execute_graphql_query(self, root, ast, operation_name, args, request_contex
 
     def _execute_operation(self, ctx, root, operation, execute_serially):
         type = get_operation_root_type(ctx.schema, operation)
-        fields = collect_fields(ctx, type, operation.selection_set, {}, set())
 
         if operation.operation == 'mutation' or execute_serially:
+            execute_serially = True
+
+        fields = DefaultOrderedDict(list) if execute_serially else collections.defaultdict(list)
+        fields = collect_fields(ctx, type, operation.selection_set, fields, set())
+
+        if execute_serially:
             return self._execute_fields_serially(ctx, type, root, fields)
 
         return self._execute_fields(ctx, type, root, fields)
@@ -276,7 +282,7 @@ def complete_value(self, ctx, return_type, field_asts, info, result):
             )
 
         # Collect sub-fields to execute to complete this value.
-        subfield_asts = {}
+        subfield_asts = collections.defaultdict(list)
         visited_fragment_names = set()
         for field_ast in field_asts:
             selection_set = field_ast.selection_set

graphql/core/pyutils/__init__.py

@@ -0,0 +1,18 @@
+class PairSet(object):
+    def __init__(self):
+        self._data = set()
+
+    def __contains__(self, item):
+        return item in self._data
+
+    def has(self, a, b):
+        return (a, b) in self._data
+
+    def add(self, a, b):
+        self._data.add((a, b))
+        self._data.add((b, a))
+        return self
+
+    def remove(self, a, b):
+        self._data.discard((a, b))
+        self._data.discard((b, a))

graphql/core/validation/rules/utils.py renamed to graphql/core/pyutils/default_ordered_dict.py

@@ -1,26 +1,6 @@
 from collections import Callable, OrderedDict
 
 
-class PairSet(object):
-    def __init__(self):
-        self._data = set()
-
-    def __contains__(self, item):
-        return item in self._data
-
-    def has(self, a, b):
-        return (a, b) in self._data
-
-    def add(self, a, b):
-        self._data.add((a, b))
-        self._data.add((b, a))
-        return self
-
-    def remove(self, a, b):
-        self._data.discard((a, b))
-        self._data.discard((b, a))
-
-
 class DefaultOrderedDict(OrderedDict):
     # Source: http://stackoverflow.com/a/6190500/562769
     def __init__(self, default_factory=None, *a, **kw):

graphql/core/pyutils/pair_set.py

@@ -0,0 +1,18 @@
+class PairSet(object):
+    def __init__(self):
+        self._data = set()
+
+    def __contains__(self, item):
+        return item in self._data
+
+    def has(self, a, b):
+        return (a, b) in self._data
+
+    def add(self, a, b):
+        self._data.add((a, b))
+        self._data.add((b, a))
+        return self
+
+    def remove(self, a, b):
+        self._data.discard((a, b))
+        self._data.discard((b, a))

graphql/core/validation/rules/overlapping_fields_can_be_merged.py

@@ -3,14 +3,15 @@
 from ...error import GraphQLError
 from ...language import ast
 from ...language.printer import print_ast
+from ...pyutils.default_ordered_dict import DefaultOrderedDict
+from ...pyutils.pair_set import PairSet
 from ...type.definition import (
     GraphQLInterfaceType,
     GraphQLObjectType,
     get_named_type,
 )
 from ...utils.type_from_ast import type_from_ast
 from .base import ValidationRule
-from .utils import DefaultOrderedDict, PairSet
 
 
 class OverlappingFieldsCanBeMerged(ValidationRule):

setup.py

@@ -1,27 +1,4 @@
-import sys
-
 from setuptools import setup, find_packages
-from setuptools.command.test import test as TestCommand
-
-
-class PyTest(TestCommand):
-    user_options = [('pytest-args=', 'a', "Arguments to pass to py.test")]
-
-    def initialize_options(self):
-        TestCommand.initialize_options(self)
-        self.pytest_args = []
-
-    def finalize_options(self):
-        TestCommand.finalize_options(self)
-        self.test_args = []
-        self.test_suite = True
-
-    def run_tests(self):
-        # import here, cause outside the eggs aren't loaded
-        import pytest
-        errno = pytest.main(self.pytest_args)
-        sys.exit(errno)
-
 
 setup(
     name='graphql-core',
@@ -50,14 +27,13 @@ def run_tests(self):
 
     keywords='api graphql protocol rest',
 
-    packages=find_packages(exclude=['tests']),
+    packages=find_packages(exclude=['tests', 'tests_py35']),
 
     install_requires=['six>=1.10.0'],
     tests_require=['pytest>=2.7.3', 'gevent==1.1b5', 'six>=1.10.0'],
     extras_require={
         'gevent': [
             'gevent==1.1b5'
         ]
-    },
-    cmdclass={'test': PyTest},
+    }
 )

tests/core_pyutils/test_pair_set.py

@@ -0,0 +1,27 @@
+from graphql.core.pyutils.pair_set import PairSet
+
+
+def test_pair_set():
+    ps = PairSet()
+
+    ps.add(1, 2)
+    ps.add(2, 4)
+
+    assert ps.has(1, 2)
+    assert ps.has(2, 1)
+    assert (1, 2) in ps
+    assert (2, 1) in ps
+    assert ps.has(4, 2)
+    assert ps.has(2, 4)
+
+    assert not ps.has(2, 3)
+    assert not ps.has(1, 3)
+
+    ps.remove(1, 2)
+    assert not ps.has(1, 2)
+    assert not ps.has(2, 1)
+    assert (1, 2) not in ps
+    assert (2, 1) not in ps
+
+    assert ps.has(4, 2)
+    assert ps.has(2, 4)