AST Printer

Author: dittos

graphql/core/executor/values.py

@@ -1,18 +1,14 @@
 import collections
 from ..error import GraphQLError
 from ..language import ast
+from ..language.printer import print_ast
 from ..type import (GraphQLNonNull, GraphQLList, GraphQLInputObjectType,
                     GraphQLScalarType, GraphQLEnumType, is_input_type)
 from ..utils import type_from_ast, is_nullish
 
 __all__ = ['get_variable_values', 'get_argument_values']
 
 
-def print_ast(ast):
-    # TODO: replace to real printer
-    return repr(ast)
-
-
 def get_variable_values(schema, definition_asts, inputs):
     """Prepares an object map of variables of the correct type based on the provided variable definitions and arbitrary input.
     If the input cannot be coerced to match the variable definitions, a GraphQLError will be thrown."""

graphql/core/language/printer.py

@@ -0,0 +1,126 @@
+import json
+from .visitor import visit, Visitor
+
+__all__ = ['print_ast']
+
+
+def print_ast(ast):
+    return visit(ast, PrintingVisitor())
+
+
+class PrintingVisitor(Visitor):
+    def leave_Name(self, node, *args):
+        return node.value
+
+    def leave_Variable(self, node, *args):
+        return '$' + node.name
+
+    def leave_Document(self, node, *args):
+        return join(node.definitions, '\n\n') + '\n'
+
+    def leave_OperationDefinition(self, node, *args):
+        name = node.name
+        selection_set = node.selection_set
+        if not name:
+            return selection_set
+        op = node.operation
+        defs = wrap('(', join(node.variable_definitions, ', '), ')')
+        directives = join(node.directives, ' ')
+        return join([op, join([name, defs]), directives, selection_set], ' ')
+
+    def leave_VariableDefinition(self, node, *args):
+        return node.variable + ': ' + node.type + wrap(' = ', node.default_value)
+
+    def leave_SelectionSet(self, node, *args):
+        return block(node.selections)
+
+    def leave_Field(self, node, *args):
+        return join([
+            wrap('', node.alias, ': ') + node.name + wrap('(', join(node.arguments, ', '), ')'),
+            join(node.directives, ' '),
+            node.selection_set
+        ], ' ')
+
+    def leave_Argument(self, node, *args):
+        return node.name + ': ' + node.value
+
+    # Fragments
+
+    def leave_FragmentSpread(self, node, *args):
+        return '...' + node.name + wrap(' ', join(node.directives, ' '))
+
+    def leave_InlineFragment(self, node, *args):
+        return ('... on ' + node.type_condition + ' ' +
+                wrap('', join(node.directives, ' '), ' ') +
+                node.selection_set)
+
+    def leave_FragmentDefinition(self, node, *args):
+        return ('fragment {} on {} '.format(node.name, node.type_condition) +
+                wrap('', join(node.directives, ' '), ' ') +
+                node.selection_set)
+
+    # Value
+
+    def leave_IntValue(self, node, *args):
+        return node.value
+
+    def leave_FloatValue(self, node, *args):
+        return node.value
+
+    def leave_StringValue(self, node, *args):
+        return json.dumps(node.value)
+
+    def leave_BooleanValue(self, node, *args):
+        return json.dumps(node.value)
+
+    def leave_EnumValue(self, node, *args):
+        return node.value
+
+    def leave_ListValue(self, node, *args):
+        return '[' + join(node.values, ', ') + ']'
+
+    def leave_ObjectValue(self, node, *args):
+        return '{' + join(node.fields, ', ') + '}'
+
+    def leave_ObjectField(self, node, *args):
+        return node.name + ': ' + node.value
+
+    # Directive
+
+    def leave_Directive(self, node, *args):
+        return '@' + node.name + wrap('(', join(node.arguments, ', '), ')')
+
+    # Type
+
+    def leave_NamedType(self, node, *args):
+        return node.name
+
+    def leave_ListType(self, node, *args):
+        return '[' + node.type + ']'
+
+    def leave_NonNullType(self, node, *args):
+        return node.type + '!'
+
+
+def join(maybe_list, separator=''):
+    if maybe_list:
+        return separator.join(filter(None, maybe_list))
+    return ''
+
+
+def block(maybe_list):
+    if maybe_list:
+        return indent('{\n' + join(maybe_list, '\n')) + '\n}'
+    return ''
+
+
+def wrap(start, maybe_str, end=''):
+    if maybe_str:
+        return start + maybe_str + end
+    return ''
+
+
+def indent(maybe_str):
+    if maybe_str:
+        return maybe_str.replace('\n', '\n  ')
+    return maybe_str

tests/core_language/test_printer.py

@@ -0,0 +1,67 @@
+import copy
+from graphql.core.language.ast import Field, Name
+from graphql.core.language.parser import parse
+from graphql.core.language.printer import print_ast
+from pytest import raises
+from fixtures import KITCHEN_SINK
+
+
+def test_does_not_alter_ast():
+    ast = parse(KITCHEN_SINK)
+    ast_copy = copy.deepcopy(ast)
+    print_ast(ast)
+    assert ast == ast_copy
+
+
+def test_prints_minimal_ast():
+    ast = Field(name=Name(loc=None, value='foo'),
+                loc=None,
+                alias=None,
+                arguments=None,
+                directives=None,
+                selection_set=None)
+    assert print_ast(ast) == 'foo'
+
+
+def test_produces_helpful_error_messages():
+    bad_ast = {'random': 'Data'}
+    with raises(Exception) as excinfo:
+        print_ast(bad_ast)
+    assert 'Invalid AST Node' in str(excinfo.value)
+
+
+def test_prints_kitchen_sink():
+    ast = parse(KITCHEN_SINK)
+    printed = print_ast(ast)
+    assert printed == '''query queryName($foo: ComplexType, $site: Site = MOBILE) {
+  whoever123is: node(id: [123, 456]) {
+    id
+    ... on User @defer {
+      field2 {
+        id
+        alias: field1(first: 10, after: $foo) @include(if: $foo) {
+          id
+          ...frag
+        }
+      }
+    }
+  }
+}
+
+mutation likeStory {
+  like(story: 123) @defer {
+    story {
+      id
+    }
+  }
+}
+
+fragment frag on Friend {
+  foo(size: $size, bar: $b, obj: {key: "value"})
+}
+
+{
+  unnamed(truthy: true, falsey: false)
+  query
+}
+'''