graphql 1.7.7 → 1.7.8

data/lib/graphql/language/generation.rb

@@ -14,189 +14,10 @@ module GraphQL
       #
       # @param node [GraphQL::Language::Nodes::AbstractNode] an AST node to recursively stringify
       # @param indent [String] Whitespace to add to each printed node
+      # @param printer [GraphQL::Language::Printer] An optional custom printer for printing AST nodes. Defaults to GraphQL::Language::Printer
       # @return [String] Valid GraphQL for `node`
-      def generate(node, indent: "")
-        case node
-        when Nodes::Document
-          node.definitions.map { |d| generate(d) }.join("\n\n")
-        when Nodes::Argument
-          "#{node.name}: #{generate(node.value)}".dup
-        when Nodes::Directive
-          out = "@#{node.name}".dup
-          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
-          out
-        when Nodes::Enum
-          "#{node.name}".dup
-        when Nodes::NullValue
-          "null".dup
-        when Nodes::Field
-          out = "#{indent}".dup
-          out << "#{node.alias}: " if node.alias
-          out << "#{node.name}"
-          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
-          out << generate_directives(node.directives)
-          out << generate_selections(node.selections, indent: indent)
-          out
-        when Nodes::FragmentDefinition
-          out = "#{indent}fragment #{node.name}".dup
-          if node.type
-            out << " on #{generate(node.type)}"
-          end
-          out << generate_directives(node.directives)
-          out << generate_selections(node.selections, indent: indent)
-          out
-        when Nodes::FragmentSpread
-          out = "#{indent}...#{node.name}".dup
-          out << generate_directives(node.directives)
-          out
-        when Nodes::InlineFragment
-          out = "#{indent}...".dup
-          if node.type
-            out << " on #{generate(node.type)}"
-          end
-          out << generate_directives(node.directives)
-          out << generate_selections(node.selections, indent: indent)
-          out
-        when Nodes::InputObject
-          generate(node.to_h)
-        when Nodes::ListType
-          "[#{generate(node.of_type)}]".dup
-        when Nodes::NonNullType
-          "#{generate(node.of_type)}!".dup
-        when Nodes::OperationDefinition
-          out = "#{indent}#{node.operation_type}".dup
-          out << " #{node.name}" if node.name
-          out << "(#{node.variables.map { |v| generate(v) }.join(", ")})" if node.variables.any?
-          out << generate_directives(node.directives)
-          out << generate_selections(node.selections, indent: indent)
-          out
-        when Nodes::TypeName
-          "#{node.name}".dup
-        when Nodes::VariableDefinition
-          out = "$#{node.name}: #{generate(node.type)}".dup
-          out << " = #{generate(node.default_value)}" unless node.default_value.nil?
-          out
-        when Nodes::VariableIdentifier
-          "$#{node.name}".dup
-        when Nodes::SchemaDefinition
-          if (node.query.nil? || node.query == 'Query') &&
-             (node.mutation.nil? || node.mutation == 'Mutation') &&
-             (node.subscription.nil? || node.subscription == 'Subscription')
-            return
-          end
-
-          out = "schema {\n".dup
-          out << "  query: #{node.query}\n" if node.query
-          out << "  mutation: #{node.mutation}\n" if node.mutation
-          out << "  subscription: #{node.subscription}\n" if node.subscription
-          out << "}"
-        when Nodes::ScalarTypeDefinition
-          out = generate_description(node)
-          out << "scalar #{node.name}"
-          out << generate_directives(node.directives)
-        when Nodes::ObjectTypeDefinition
-          out = generate_description(node)
-          out << "type #{node.name}"
-          out << generate_directives(node.directives)
-          out << " implements " << node.interfaces.map(&:name).join(", ") unless node.interfaces.empty?
-          out << generate_field_definitions(node.fields)
-        when Nodes::InputValueDefinition
-          out = "#{node.name}: #{generate(node.type)}".dup
-          out << " = #{generate(node.default_value)}" unless node.default_value.nil?
-          out << generate_directives(node.directives)
-        when Nodes::FieldDefinition
-          out = node.name.dup
-          unless node.arguments.empty?
-            out << "(" << node.arguments.map{ |arg| generate(arg) }.join(", ") << ")"
-          end
-          out << ": #{generate(node.type)}"
-          out << generate_directives(node.directives)
-        when Nodes::InterfaceTypeDefinition
-          out = generate_description(node)
-          out << "interface #{node.name}"
-          out << generate_directives(node.directives)
-          out << generate_field_definitions(node.fields)
-        when Nodes::UnionTypeDefinition
-          out = generate_description(node)
-          out << "union #{node.name}"
-          out << generate_directives(node.directives)
-          out << " = " + node.types.map(&:name).join(" | ")
-        when Nodes::EnumTypeDefinition
-          out = generate_description(node)
-          out << "enum #{node.name}#{generate_directives(node.directives)} {\n"
-          node.values.each.with_index do |value, i|
-            out << generate_description(value, indent: '  ', first_in_block: i == 0)
-            out << generate(value)
-          end
-          out << "}"
-        when Nodes::EnumValueDefinition
-          out = "  #{node.name}".dup
-          out << generate_directives(node.directives)
-          out << "\n"
-        when Nodes::InputObjectTypeDefinition
-          out = generate_description(node)
-          out << "input #{node.name}"
-          out << generate_directives(node.directives)
-          out << " {\n"
-          node.fields.each.with_index do |field, i|
-            out << generate_description(field, indent: '  ', first_in_block: i == 0)
-            out << "  #{generate(field)}\n"
-          end
-          out << "}"
-        when Nodes::DirectiveDefinition
-          out = generate_description(node)
-          out << "directive @#{node.name}"
-          out << "(#{node.arguments.map { |a| generate(a) }.join(", ")})" if node.arguments.any?
-          out << " on #{node.locations.join(' | ')}"
-        when Nodes::AbstractNode
-          node.to_query_string(indent: indent)
-        when FalseClass, Float, Integer, NilClass, String, TrueClass
-          GraphQL::Language.serialize(node)
-        when Array
-          "[#{node.map { |v| generate(v) }.join(", ")}]".dup
-        when Hash
-          "{#{node.map { |k, v| "#{k}: #{generate(v)}" }.join(", ")}}".dup
-        else
-          raise TypeError
-        end
-      end
-
-      private
-
-      def generate_directives(directives)
-        if directives.any?
-          directives.map { |d| " #{generate(d)}" }.join
-        else
-          ""
-        end
-      end
-
-      def generate_selections(selections, indent: "")
-        if selections.any?
-          out = " {\n".dup
-          selections.each do |selection|
-            out << generate(selection, indent: indent + "  ") << "\n"
-          end
-          out << "#{indent}}"
-        else
-          ""
-        end
-      end
-
-      def generate_description(node, indent: '', first_in_block: true)
-        return ''.dup unless node.description
-
-        description = indent != '' && !first_in_block ? "\n".dup : "".dup
-        description << GraphQL::Language::Comments.commentize(node.description, indent: indent)
-      end
-
-      def generate_field_definitions(fields)
-        out = " {\n".dup
-        fields.each.with_index do |field, i|
-          out << generate_description(field, indent: '  ', first_in_block: i == 0)
-          out << "  #{generate(field)}\n"
-        end
-        out << "}"
+      def generate(node, indent: "", printer: GraphQL::Language::Printer.new)
+        printer.print(node, indent: indent)
       end
     end
   end

data/lib/graphql/language/nodes.rb

@@ -8,6 +8,7 @@ module GraphQL
       # - `children` returns all AST nodes attached to this one. Used for tree traversal.
       # - `scalars` returns all scalar (Ruby) values attached to this one. Used for comparing nodes.
       # - `to_query_string` turns an AST node into a GraphQL string
+
       class AbstractNode
         attr_accessor :line, :col, :filename
 
@@ -77,8 +78,8 @@ module GraphQL
           [line, col]
         end
 
-        def to_query_string
-          Generation.generate(self)
+        def to_query_string(printer: GraphQL::Language::Printer.new)
+          printer.print(self)
         end
       end
 
@@ -164,6 +165,15 @@ module GraphQL
       #   document.to_query_string
       #   # { ... }
       #
+      # @example Creating a custom string from a document
+      #  class VariableScrubber < GraphQL::Language::Printer
+      #    def print_argument(arg)
+      #      "#{arg.name}: <HIDDEN>"
+      #    end
+      #  end
+      #
+      #  document.to_query_string(printer: VariableSrubber.new)
+      #
       class Document < AbstractNode
         attr_accessor :definitions
         child_attributes :definitions

data/lib/graphql/language/parser.rb

@@ -12,7 +12,7 @@ module GraphQL
   module Language
     class Parser < Racc::Parser
 
-module_eval(<<'...end parser.y/module_eval...', 'parser.y', 372)
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 373)
 
 def initialize(query_string, filename:, tracer: Tracing::NullTracer)
   @query_string = query_string
@@ -425,30 +425,30 @@ racc_action_pointer = [
    nil,   nil,   nil,   nil ]
 
 racc_action_default = [
-  -145,  -145,    -1,    -2,    -3,    -5,    -6,    -7,   -14,  -145,
-   -11,   -12,   -13,  -109,  -111,  -112,  -113,  -145,  -118,  -119,
-  -120,  -121,  -122,  -123,  -145,  -145,  -145,  -145,  -145,  -145,
-  -145,  -145,    -4,   -16,   -15,   -37,   -38,   -39,   -40,   -41,
+  -146,  -146,    -1,    -2,    -3,    -5,    -6,    -7,   -14,  -146,
+   -11,   -12,   -13,  -109,  -111,  -112,  -113,  -146,  -118,  -119,
+  -120,  -121,  -122,  -123,  -146,  -146,  -146,  -146,  -146,  -146,
+  -146,  -146,    -4,   -16,   -15,   -37,   -38,   -39,   -40,   -41,
    -42,   -43,   -44,   -45,   -46,   -47,   -48,   -49,   -50,   -51,
-   -52,   -53,  -145,   -10,   -30,   -32,   -33,   -34,   -64,  -100,
-  -145,  -110,  -145,  -100,  -126,  -100,  -100,  -100,  -100,  -145,
-   244,  -100,  -145,    -9,   -31,  -100,  -145,  -145,  -101,  -102,
-  -145,  -100,  -145,  -145,  -145,  -145,  -115,  -145,  -124,  -100,
-  -145,  -145,  -145,  -145,  -145,  -131,  -145,  -145,   -18,  -145,
-   -28,   -64,   -65,  -145,   -67,  -145,  -103,   -64,  -105,   -21,
-  -100,  -145,  -145,  -107,  -100,  -114,  -116,  -145,  -145,   -59,
-  -127,  -145,  -145,  -145,  -145,  -145,  -145,    -8,   -17,   -19,
-  -145,   -29,   -35,  -100,   -66,   -68,   -79,  -104,   -22,  -145,
-  -145,   -26,  -145,  -145,  -117,  -145,   -60,  -131,  -134,  -145,
-  -137,  -139,   -54,   -55,   -56,   -57,   -58,  -100,   -62,  -145,
-  -145,  -129,  -145,  -145,  -145,  -145,   -28,   -69,   -70,   -71,
+   -52,   -53,  -146,   -10,   -30,   -32,   -33,   -34,   -64,  -100,
+  -146,  -110,  -146,  -100,  -126,  -100,  -100,  -100,  -100,  -146,
+   244,  -100,  -146,    -9,   -31,  -100,  -146,  -146,  -101,  -102,
+  -146,  -100,  -146,  -146,  -146,  -146,  -115,  -146,  -124,  -100,
+  -146,  -146,  -146,  -146,  -146,  -131,  -146,  -146,   -18,  -146,
+   -28,   -64,   -65,  -146,   -67,  -146,  -103,   -64,  -105,   -21,
+  -100,  -146,  -146,  -107,  -100,  -114,  -116,  -146,  -146,   -59,
+  -127,  -134,  -146,  -146,  -146,  -146,  -146,    -8,   -17,   -19,
+  -146,   -29,   -35,  -100,   -66,   -68,   -79,  -104,   -22,  -146,
+  -146,   -26,  -146,  -146,  -117,  -134,   -60,  -131,  -135,  -146,
+  -138,  -140,   -54,   -55,   -56,   -57,   -58,  -100,   -62,  -146,
+  -146,  -129,  -146,  -146,  -146,  -146,   -28,   -69,   -70,   -71,
    -72,   -73,   -74,   -75,   -76,   -77,   -78,   -80,   -81,   -82,
-   -83,  -145,  -145,  -145,   -99,  -106,   -23,   -27,  -108,  -145,
-  -145,  -135,  -136,  -145,   -61,   -63,  -140,  -145,  -130,  -141,
-  -132,  -142,  -143,   -24,   -36,   -84,   -85,  -145,   -87,   -89,
-  -145,   -91,  -145,  -145,   -96,  -125,  -145,  -138,   -24,  -145,
-   -20,  -145,   -86,   -88,   -90,   -92,  -145,   -79,   -95,   -97,
-  -145,  -100,  -100,  -144,   -25,  -145,   -79,   -80,   -93,  -145,
+   -83,  -146,  -146,  -146,   -99,  -106,   -23,   -27,  -108,  -146,
+  -146,  -136,  -137,  -146,   -61,   -63,  -141,  -146,  -130,  -142,
+  -132,  -143,  -144,   -24,   -36,   -84,   -85,  -146,   -87,   -89,
+  -146,   -91,  -146,  -146,   -96,  -125,  -146,  -139,   -24,  -146,
+   -20,  -146,   -86,   -88,   -90,   -92,  -146,   -79,   -95,   -97,
+  -146,  -100,  -100,  -145,   -25,  -146,   -79,   -80,   -93,  -146,
   -133,  -128,   -94,   -98 ]
 
 racc_goto_table = [
@@ -656,19 +656,20 @@ racc_reduce_table = [
   0, 100, :_reduce_131,
   3, 100, :_reduce_132,
   5, 101, :_reduce_133,
-  1, 97, :_reduce_134,
-  2, 97, :_reduce_135,
-  6, 92, :_reduce_136,
-  1, 102, :_reduce_137,
-  3, 102, :_reduce_138,
-  5, 93, :_reduce_139,
-  6, 94, :_reduce_140,
-  6, 95, :_reduce_141,
-  6, 87, :_reduce_142,
-  1, 103, :_reduce_143,
-  3, 103, :_reduce_144 ]
-
-racc_reduce_n = 145
+  0, 97, :_reduce_134,
+  1, 97, :_reduce_135,
+  2, 97, :_reduce_136,
+  6, 92, :_reduce_137,
+  1, 102, :_reduce_138,
+  3, 102, :_reduce_139,
+  5, 93, :_reduce_140,
+  6, 94, :_reduce_141,
+  6, 95, :_reduce_142,
+  6, 87, :_reduce_143,
+  1, 103, :_reduce_144,
+  3, 103, :_reduce_145 ]
+
+racc_reduce_n = 146
 
 racc_shift_n = 244
 
@@ -1582,81 +1583,88 @@ module_eval(<<'.,.,', 'parser.y', 326)
 
 module_eval(<<'.,.,', 'parser.y', 330)
   def _reduce_134(val, _values, result)
-     return [val[0]] 
+     return [] 
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 331)
   def _reduce_135(val, _values, result)
-     val[0] << val[1] 
+     return [val[0]] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 335)
+module_eval(<<'.,.,', 'parser.y', 332)
   def _reduce_136(val, _values, result)
-            return make_node(:InterfaceTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]), position_source: val[0])
-      
+     val[0] << val[1] 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 339)
+module_eval(<<'.,.,', 'parser.y', 336)
   def _reduce_137(val, _values, result)
-     return [make_node(:TypeName, name: val[0])]
+            return make_node(:InterfaceTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]), position_source: val[0])
+      
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 340)
   def _reduce_138(val, _values, result)
-     val[0] << make_node(:TypeName, name: val[2]) 
+     return [make_node(:TypeName, name: val[0])]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 344)
+module_eval(<<'.,.,', 'parser.y', 341)
   def _reduce_139(val, _values, result)
-            return make_node(:UnionTypeDefinition, name: val[1], directives: val[2], types: val[4], description: get_description(val[0]), position_source: val[0])
-      
+     val[0] << make_node(:TypeName, name: val[2]) 
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 349)
+module_eval(<<'.,.,', 'parser.y', 345)
   def _reduce_140(val, _values, result)
-             return make_node(:EnumTypeDefinition, name: val[1], directives: val[2], values: val[4], description: get_description(val[0]), position_source: val[0])
+            return make_node(:UnionTypeDefinition, name: val[1], directives: val[2], types: val[4], description: get_description(val[0]), position_source: val[0])
       
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 354)
+module_eval(<<'.,.,', 'parser.y', 350)
   def _reduce_141(val, _values, result)
-            return make_node(:InputObjectTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]), position_source: val[0])
+             return make_node(:EnumTypeDefinition, name: val[1], directives: val[2], values: val[4], description: get_description(val[0]), position_source: val[0])
       
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 359)
+module_eval(<<'.,.,', 'parser.y', 355)
   def _reduce_142(val, _values, result)
-            return make_node(:DirectiveDefinition, name: val[2], arguments: val[3], locations: val[5], description: get_description(val[0]), position_source: val[0])
+            return make_node(:InputObjectTypeDefinition, name: val[1], directives: val[2], fields: val[4], description: get_description(val[0]), position_source: val[0])
       
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'parser.y', 363)
+module_eval(<<'.,.,', 'parser.y', 360)
   def _reduce_143(val, _values, result)
-     return [val[0].to_s] 
+            return make_node(:DirectiveDefinition, name: val[2], arguments: val[3], locations: val[5], description: get_description(val[0]), position_source: val[0])
+      
     result
   end
 .,.,
 
 module_eval(<<'.,.,', 'parser.y', 364)
   def _reduce_144(val, _values, result)
+     return [val[0].to_s] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 365)
+  def _reduce_145(val, _values, result)
      val[0] << val[2].to_s 
     result
   end

data/lib/graphql/language/parser.y

@@ -328,7 +328,8 @@ rule
       }
 
   field_definition_list:
-      field_definition                       { return [val[0]] }
+    /* none */ { return [] }
+    | field_definition                       { return [val[0]] }
     | field_definition_list field_definition { val[0] << val[1] }
 
   interface_type_definition:

data/lib/graphql/language/printer.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    class Printer
+      # Turn an arbitrary AST node back into a string.
+      #
+      # @example Turning a document into a query string
+      #    document = GraphQL.parse(query_string)
+      #    GraphQL::Language::Printer.new.print(document)
+      #    # => "{ ... }"
+      #
+      #
+      # @example Building a custom printer
+      #
+      #  class MyPrinter < GraphQL::Language::Printer
+      #    def print_argument(arg)
+      #      "#{arg.name}: <HIDDEN>"
+      #    end
+      #  end
+      #
+      #  MyPrinter.new.print(document)
+      #  # => "mutation { pay(creditCard: <HIDDEN>) { success } }"
+      #
+      #
+      # @param indent [String] Whitespace to add to the printed node
+      # @return [String] Valid GraphQL for `node`
+      def print(node, indent: "")
+        print_node(node, indent: indent)
+      end
+
+      protected
+
+      def print_document(document)
+        document.definitions.map { |d| print_node(d) }.join("\n\n")
+      end
+
+      def print_argument(argument)
+        "#{argument.name}: #{print_node(argument.value)}".dup
+      end
+
+      def print_directive(directive)
+        out = "@#{directive.name}".dup
+
+        if directive.arguments.any?
+          out << "(#{directive.arguments.map { |a| print_argument(a) }.join(", ")})"
+        end
+
+        out
+      end
+
+      def print_enum(enum)
+        "#{enum.name}".dup
+      end
+
+      def print_null_value
+        "null".dup
+      end
+
+      def print_field(field, indent: "")
+        out = "#{indent}".dup
+        out << "#{field.alias}: " if field.alias
+        out << "#{field.name}"
+        out << "(#{field.arguments.map { |a| print_argument(a) }.join(", ")})" if field.arguments.any?
+        out << print_directives(field.directives)
+        out << print_selections(field.selections, indent: indent)
+        out
+      end
+
+      def print_fragment_definition(fragment_def, indent: "")
+        out = "#{indent}fragment #{fragment_def.name}".dup
+        if fragment_def.type
+          out << " on #{print_node(fragment_def.type)}"
+        end
+        out << print_directives(fragment_def.directives)
+        out << print_selections(fragment_def.selections, indent: indent)
+        out
+      end
+
+      def print_fragment_spread(fragment_spread, indent: "")
+        out = "#{indent}...#{fragment_spread.name}".dup
+        out << print_directives(fragment_spread.directives)
+        out
+      end
+
+      def print_inline_fragment(inline_fragment, indent: "")
+        out = "#{indent}...".dup
+        if inline_fragment.type
+          out << " on #{print_node(inline_fragment.type)}"
+        end
+        out << print_directives(inline_fragment.directives)
+        out << print_selections(inline_fragment.selections, indent: indent)
+        out
+      end
+
+      def print_input_object(input_object)
+        print_node(input_object.to_h)
+      end
+
+      def print_list_type(list_type)
+        "[#{print_node(list_type.of_type)}]".dup
+      end
+
+      def print_non_null_type(non_null_type)
+        "#{print_node(non_null_type.of_type)}!".dup
+      end
+
+      def print_operation_definition(operation_definition, indent: "")
+        out = "#{indent}#{operation_definition.operation_type}".dup
+        out << " #{operation_definition.name}" if operation_definition.name
+
+        if operation_definition.variables.any?
+          out << "(#{operation_definition.variables.map { |v| print_variable_definition(v) }.join(", ")})"
+        end
+
+        out << print_directives(operation_definition.directives)
+        out << print_selections(operation_definition.selections, indent: indent)
+        out
+      end
+
+      def print_type_name(type_name)
+        "#{type_name.name}".dup
+      end
+
+      def print_variable_definition(variable_definition)
+        out = "$#{variable_definition.name}: #{print_node(variable_definition.type)}".dup
+        out << " = #{print_node(variable_definition.default_value)}" unless variable_definition.default_value.nil?
+        out
+      end
+
+      def print_variable_identifier(variable_identifier)
+        "$#{variable_identifier.name}".dup
+      end
+
+      def print_schema_definition(schema)
+        if (schema.query.nil? || schema.query == 'Query') &&
+           (schema.mutation.nil? || schema.mutation == 'Mutation') &&
+           (schema.subscription.nil? || schema.subscription == 'Subscription')
+          return
+        end
+
+        out = "schema {\n".dup
+        out << "  query: #{schema.query}\n" if schema.query
+        out << "  mutation: #{schema.mutation}\n" if schema.mutation
+        out << "  subscription: #{schema.subscription}\n" if schema.subscription
+        out << "}"
+      end
+
+      def print_scalar_type_definition(scalar_type)
+        out = print_description(scalar_type)
+        out << "scalar #{scalar_type.name}"
+        out << print_directives(scalar_type.directives)
+      end
+
+      def print_object_type_definition(object_type)
+        out = print_description(object_type)
+        out << "type #{object_type.name}"
+        out << print_directives(object_type.directives)
+        out << " implements " << object_type.interfaces.map(&:name).join(", ") unless object_type.interfaces.empty?
+        out << print_field_definitions(object_type.fields)
+      end
+
+      def print_input_value_definition(input_value)
+        out = "#{input_value.name}: #{print_node(input_value.type)}".dup
+        out << " = #{print_node(input_value.default_value)}" unless input_value.default_value.nil?
+        out << print_directives(input_value.directives)
+      end
+
+      def print_arguments(arguments, indent: "")
+        if arguments.all?{ |arg| !arg.description }
+          return "(#{arguments.map{ |arg| print_input_value_definition(arg) }.join(", ")})"
+        end
+
+        out = "(\n".dup
+        out << arguments.map.with_index{ |arg, i|
+          "#{print_description(arg, indent: "  " + indent, first_in_block: i == 0)}  #{indent}"\
+          "#{print_input_value_definition(arg)}"
+        }.join("\n")
+        out << "\n#{indent})"
+      end
+
+      def print_field_definition(field)
+        out = field.name.dup
+        unless field.arguments.empty?
+          out << print_arguments(field.arguments, indent: "  ")
+        end
+        out << ": #{print_node(field.type)}"
+        out << print_directives(field.directives)
+      end
+
+      def print_interface_type_definition(interface_type)
+        out = print_description(interface_type)
+        out << "interface #{interface_type.name}"
+        out << print_directives(interface_type.directives)
+        out << print_field_definitions(interface_type.fields)
+      end
+
+      def print_union_type_definition(union_type)
+        out = print_description(union_type)
+        out << "union #{union_type.name}"
+        out << print_directives(union_type.directives)
+        out << " = " + union_type.types.map(&:name).join(" | ")
+      end
+
+      def print_enum_type_definition(enum_type)
+        out = print_description(enum_type)
+        out << "enum #{enum_type.name}#{print_directives(enum_type.directives)} {\n"
+        enum_type.values.each.with_index do |value, i|
+          out << print_description(value, indent: '  ', first_in_block: i == 0)
+          out << print_enum_value_definition(value)
+        end
+        out << "}"
+      end
+
+      def print_enum_value_definition(enum_value)
+        out = "  #{enum_value.name}".dup
+        out << print_directives(enum_value.directives)
+        out << "\n"
+      end
+
+      def print_input_object_type_definition(input_object_type)
+        out = print_description(input_object_type)
+        out << "input #{input_object_type.name}"
+        out << print_directives(input_object_type.directives)
+        out << " {\n"
+        input_object_type.fields.each.with_index do |field, i|
+          out << print_description(field, indent: '  ', first_in_block: i == 0)
+          out << "  #{print_input_value_definition(field)}\n"
+        end
+        out << "}"
+      end
+
+      def print_directive_definition(directive)
+        out = print_description(directive)
+        out << "directive @#{directive.name}"
+
+        if directive.arguments.any?
+          out << print_arguments(directive.arguments)
+        end
+
+        out << " on #{directive.locations.join(' | ')}"
+      end
+
+      def print_description(node, indent: "", first_in_block: true)
+        return ''.dup unless node.description
+
+        description = indent != '' && !first_in_block ? "\n".dup : "".dup
+        description << GraphQL::Language::Comments.commentize(node.description, indent: indent)
+      end
+
+      def print_field_definitions(fields)
+        out = " {\n".dup
+        fields.each.with_index do |field, i|
+          out << print_description(field, indent: '  ', first_in_block: i == 0)
+          out << "  #{print_field_definition(field)}\n"
+        end
+        out << "}"
+      end
+
+      def print_directives(directives)
+        if directives.any?
+          directives.map { |d| " #{print_directive(d)}" }.join
+        else
+          ""
+        end
+      end
+
+      def print_selections(selections, indent: "")
+        if selections.any?
+          out = " {\n".dup
+          selections.each do |selection|
+            out << print_node(selection, indent: indent + "  ") << "\n"
+          end
+          out << "#{indent}}"
+        else
+          ""
+        end
+      end
+
+      def print_node(node, indent: "")
+        case node
+        when Nodes::Document
+          print_document(node)
+        when Nodes::Argument
+          print_argument(node)
+        when Nodes::Directive
+          print_directive(node)
+        when Nodes::Enum
+          print_enum(node)
+        when Nodes::NullValue
+          print_null_value
+        when Nodes::Field
+          print_field(node, indent: indent)
+        when Nodes::FragmentDefinition
+          print_fragment_definition(node, indent: indent)
+        when Nodes::FragmentSpread
+          print_fragment_spread(node, indent: indent)
+        when Nodes::InlineFragment
+          print_inline_fragment(node, indent: indent)
+        when Nodes::InputObject
+          print_input_object(node)
+        when Nodes::ListType
+          print_list_type(node)
+        when Nodes::NonNullType
+          print_non_null_type(node)
+        when Nodes::OperationDefinition
+          print_operation_definition(node, indent: indent)
+        when Nodes::TypeName
+          print_type_name(node)
+        when Nodes::VariableDefinition
+          print_variable_definition(node)
+        when Nodes::VariableIdentifier
+          print_variable_identifier(node)
+        when Nodes::SchemaDefinition
+          print_schema_definition(node)
+        when Nodes::ScalarTypeDefinition
+          print_scalar_type_definition(node)
+        when Nodes::ObjectTypeDefinition
+          print_object_type_definition(node)
+        when Nodes::InputValueDefinition
+          print_input_value_definition(node)
+        when Nodes::FieldDefinition
+          print_field_definition(node)
+        when Nodes::InterfaceTypeDefinition
+          print_interface_type_definition(node)
+        when Nodes::UnionTypeDefinition
+          print_union_type_definition(node)
+        when Nodes::EnumTypeDefinition
+          print_enum_type_definition(node)
+        when Nodes::EnumValueDefinition
+          print_enum_value_definition(node)
+        when Nodes::InputObjectTypeDefinition
+          print_input_object_type_definition(node)
+        when Nodes::DirectiveDefinition
+          print_directive_definition(node)
+        when FalseClass, Float, Integer, NilClass, String, TrueClass, Symbol
+          GraphQL::Language.serialize(node)
+        when Array
+          "[#{node.map { |v| print_node(v) }.join(", ")}]".dup
+        when Hash
+          "{#{node.map { |k, v| "#{k}: #{print_node(v)}" }.join(", ")}}".dup
+        else
+          raise TypeError
+        end
+      end
+
+      private
+
+      attr_reader :node
+    end
+  end
+end