graphql 2.1.0 → 2.1.1

data/lib/graphql/language/block_string.rb

@@ -59,40 +59,52 @@ module GraphQL
       end
 
       def self.print(str, indent: '')
-        lines = str.split("\n")
+        line_length = 120 - indent.length
+        block_str = "".dup
+        triple_quotes = "\"\"\"\n"
+        block_str << indent
+        block_str << triple_quotes
 
-        block_str = "#{indent}\"\"\"\n".dup
-
-        lines.each do |line|
-          if line == ''
-            block_str << "\n"
-          else
-            sublines = break_line(line, 120 - indent.length)
-            sublines.each do |subline|
-              block_str << "#{indent}#{subline}\n"
+        if str.include?("\n")
+          str.split("\n") do |line|
+            if line == ''
+              block_str << "\n"
+            else
+              break_line(line, line_length) do |subline|
+                block_str << indent
+                block_str << subline
+                block_str << "\n"
+              end
             end
           end
+        else
+          break_line(str, line_length) do |subline|
+            block_str << indent
+            block_str << subline
+            block_str << "\n"
+          end
         end
 
-        block_str << "#{indent}\"\"\"\n".dup
+        block_str << indent
+        block_str << triple_quotes
       end
 
       private
 
       def self.break_line(line, length)
-        return [line] if line.length < length + 5
+        return yield(line) if line.length < length + 5
 
         parts = line.split(Regexp.new("((?: |^).{15,#{length - 40}}(?= |$))"))
-        return [line] if parts.length < 4
+        return yield(line) if parts.length < 4
 
-        sublines = [parts.slice!(0, 3).join]
+        yield(parts.slice!(0, 3).join)
 
         parts.each_with_index do |part, i|
           next if i % 2 == 1
-          sublines << "#{part[1..-1]}#{parts[i + 1]}"
+          yield "#{part[1..-1]}#{parts[i + 1]}"
         end
 
-        sublines
+        nil
       end
     end
   end

data/lib/graphql/language/definition_slice.rb

@@ -15,7 +15,7 @@ module GraphQL
 
       private
 
-      class DependencyVisitor < GraphQL::Language::Visitor
+      class DependencyVisitor < GraphQL::Language::StaticVisitor
         def initialize(doc, definitions, names)
           @names = names
           @definitions = definitions

data/lib/graphql/language/document_from_schema_definition.rb

@@ -42,24 +42,30 @@ module GraphQL
       end
 
       def build_schema_node
-        schema_options = {
-          # `@schema.directives` is covered by `build_definition_nodes`
-          directives: definition_directives(@schema, :schema_directives),
-        }
         if !schema_respects_root_name_conventions?(@schema)
-          schema_options.merge!({
+          GraphQL::Language::Nodes::SchemaDefinition.new(
             query: (q = warden.root_type_for_operation("query")) && q.graphql_name,
             mutation: (m = warden.root_type_for_operation("mutation")) && m.graphql_name,
             subscription: (s = warden.root_type_for_operation("subscription")) && s.graphql_name,
-          })
+            directives: definition_directives(@schema, :schema_directives)
+          )
+        else
+          # A plain `schema ...` _must_ include root type definitions.
+          # If the only difference is directives, then you have to use `extend schema`
+          GraphQL::Language::Nodes::SchemaExtension.new(directives: definition_directives(@schema, :schema_directives))
         end
-        GraphQL::Language::Nodes::SchemaDefinition.new(schema_options)
       end
 
       def build_object_type_node(object_type)
+        ints = warden.interfaces(object_type)
+        if ints.any?
+          ints.sort_by!(&:graphql_name)
+          ints.map! { |iface| build_type_name_node(iface) }
+        end
+
         GraphQL::Language::Nodes::ObjectTypeDefinition.new(
           name: object_type.graphql_name,
-          interfaces: warden.interfaces(object_type).sort_by(&:graphql_name).map { |iface| build_type_name_node(iface) },
+          interfaces: ints,
           fields: build_field_nodes(warden.fields(object_type)),
           description: object_type.description,
           directives: directives(object_type),
@@ -180,7 +186,8 @@ module GraphQL
             of_type: build_type_name_node(type.of_type)
           )
         else
-          GraphQL::Language::Nodes::TypeName.new(name: type.graphql_name)
+          @cached_type_name_nodes ||= {}
+          @cached_type_name_nodes[type.graphql_name] ||= GraphQL::Language::Nodes::TypeName.new(name: type.graphql_name)
         end
       end
 
@@ -237,9 +244,13 @@ module GraphQL
       end
 
       def build_argument_nodes(arguments)
-        arguments
-          .map { |arg| build_argument_node(arg) }
-          .sort_by(&:name)
+        if arguments.any?
+          nodes = arguments.map { |arg| build_argument_node(arg) }
+          nodes.sort_by!(&:name)
+          nodes
+        else
+          arguments
+        end
       end
 
       def build_directive_nodes(directives)
@@ -253,16 +264,16 @@ module GraphQL
         if !include_built_in_directives
           dirs_to_build = dirs_to_build.reject { |directive| directive.default_directive? }
         end
-        dir_nodes = build_directive_nodes(dirs_to_build)
+        definitions = build_directive_nodes(dirs_to_build)
 
         type_nodes = build_type_definition_nodes(warden.reachable_types)
 
         if @include_one_of
           # This may have been set to true when iterating over all types
-          dir_nodes.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
+          definitions.concat(build_directive_nodes([GraphQL::Schema::Directive::OneOf]))
         end
 
-        definitions = [*dir_nodes, *type_nodes]
+        definitions.concat(type_nodes)
         if include_schema_node?
           definitions.unshift(build_schema_node)
         end
@@ -285,9 +296,9 @@ module GraphQL
       end
 
       def build_field_nodes(fields)
-        fields
-          .map { |field| build_field_node(field) }
-          .sort_by(&:name)
+        f_nodes = fields.map { |field| build_field_node(field) }
+        f_nodes.sort_by!(&:name)
+        f_nodes
       end
 
       private
@@ -310,7 +321,7 @@ module GraphQL
 
       def definition_directives(member, directives_method)
         dirs = if !member.respond_to?(directives_method) || member.directives.empty?
-          []
+          EmptyObjects::EMPTY_ARRAY
         else
           member.public_send(directives_method).map do |dir|
             args = []

data/lib/graphql/language/nodes.rb

@@ -323,7 +323,7 @@ module GraphQL
         #   @return [String, Float, Integer, Boolean, Array, InputObject, VariableIdentifier] The value passed for this key
 
         def children
-          @children ||= Array(value).flatten.select { |v| v.is_a?(AbstractNode) }
+          @children ||= Array(value).flatten.tap { _1.select! { |v| v.is_a?(AbstractNode) } }
         end
       end
 

data/lib/graphql/language/printer.rb

@@ -74,7 +74,8 @@ module GraphQL
       end
 
       def print_argument(argument)
-        print_string("#{argument.name}: ")
+        print_string(argument.name)
+        print_string(": ")
         print_node(argument.value)
       end
 
@@ -88,7 +89,8 @@ module GraphQL
       end
 
       def print_directive(directive)
-        print_string("@#{directive.name}")
+        print_string("@")
+        print_string(directive.name)
 
         if directive.arguments.any?
           print_string("(")
@@ -110,7 +112,10 @@ module GraphQL
 
       def print_field(field, indent: "")
         print_string(indent)
-        print_string("#{field.alias}: ") if field.alias
+        if field.alias
+          print_string(field.alias)
+          print_string(": ")
+        end
         print_string(field.name)
         if field.arguments.any?
           print_string("(")
@@ -125,7 +130,13 @@ module GraphQL
       end
 
       def print_fragment_definition(fragment_def, indent: "")
-        print_string("#{indent}fragment #{fragment_def.name}")
+        print_string(indent)
+        print_string("fragment")
+        if fragment_def.name
+          print_string(" ")
+          print_string(fragment_def.name)
+        end
+
         if fragment_def.type
           print_string(" on ")
           print_node(fragment_def.type)
@@ -135,12 +146,15 @@ module GraphQL
       end
 
       def print_fragment_spread(fragment_spread, indent: "")
-        print_string("#{indent}...#{fragment_spread.name}")
+        print_string(indent)
+        print_string("...")
+        print_string(fragment_spread.name)
         print_directives(fragment_spread.directives)
       end
 
       def print_inline_fragment(inline_fragment, indent: "")
-        print_string("#{indent}...")
+        print_string(indent)
+        print_string("...")
         if inline_fragment.type
           print_string(" on ")
           print_node(inline_fragment.type)
@@ -161,8 +175,12 @@ module GraphQL
       end
 
       def print_operation_definition(operation_definition, indent: "")
-        print_string("#{indent}#{operation_definition.operation_type}")
-        print_string(" #{operation_definition.name}") if operation_definition.name
+        print_string(indent)
+        print_string(operation_definition.operation_type)
+        if operation_definition.name
+          print_string(" ")
+          print_string(operation_definition.name)
+        end
 
         if operation_definition.variables.any?
           print_string("(")
@@ -182,7 +200,9 @@ module GraphQL
       end
 
       def print_variable_definition(variable_definition)
-        print_string("$#{variable_definition.name}: ")
+        print_string("$")
+        print_string(variable_definition.name)
+        print_string(": ")
         print_node(variable_definition.type)
         unless variable_definition.default_value.nil?
           print_string(" = ")
@@ -191,7 +211,8 @@ module GraphQL
       end
 
       def print_variable_identifier(variable_identifier)
-        print_string("$#{variable_identifier.name}")
+        print_string("$")
+        print_string(variable_identifier.name)
       end
 
       def print_schema_definition(schema, extension: false)
@@ -231,24 +252,35 @@ module GraphQL
 
       def print_scalar_type_definition(scalar_type, extension: false)
         extension ? print_string("extend ") : print_description(scalar_type)
-        print_string("scalar #{scalar_type.name}")
+        print_string("scalar ")
+        print_string(scalar_type.name)
         print_directives(scalar_type.directives)
       end
 
       def print_object_type_definition(object_type, extension: false)
         extension ? print_string("extend ") : print_description(object_type)
-        print_string("type #{object_type.name}")
+        print_string("type ")
+        print_string(object_type.name)
         print_implements(object_type) unless object_type.interfaces.empty?
         print_directives(object_type.directives)
         print_field_definitions(object_type.fields)
       end
 
       def print_implements(type)
-        print_string(" implements #{type.interfaces.map(&:name).join(" & ")}")
+        print_string(" implements ")
+        i = 0
+        type.interfaces.each do |int|
+          if i > 0
+            print_string(" & ")
+          end
+          print_string(int.name)
+          i += 1
+        end
       end
 
       def print_input_value_definition(input_value)
-        print_string("#{input_value.name}: ")
+        print_string(input_value.name)
+        print_string(": ")
         print_node(input_value.type)
         unless input_value.default_value.nil?
           print_string(" = ")
@@ -271,11 +303,14 @@ module GraphQL
         print_string("(\n")
         arguments.each_with_index do |arg, i|
           print_description(arg, indent: "  " + indent, first_in_block: i == 0)
-          print_string("  #{indent}")
+          print_string("  ")
+          print_string(indent)
           print_input_value_definition(arg)
           print_string("\n") if i < arguments.size - 1
         end
-        print_string("\n#{indent})")
+        print_string("\n")
+        print_string(indent)
+        print_string(")")
       end
 
       def print_field_definition(field)
@@ -290,7 +325,8 @@ module GraphQL
 
       def print_interface_type_definition(interface_type, extension: false)
         extension ? print_string("extend ") : print_description(interface_type)
-        print_string("interface #{interface_type.name}")
+        print_string("interface ")
+        print_string(interface_type.name)
         print_implements(interface_type) if interface_type.interfaces.any?
         print_directives(interface_type.directives)
         print_field_definitions(interface_type.fields)
@@ -298,14 +334,24 @@ module GraphQL
 
       def print_union_type_definition(union_type, extension: false)
         extension ? print_string("extend ") : print_description(union_type)
-        print_string("union #{union_type.name}")
+        print_string("union ")
+        print_string(union_type.name)
         print_directives(union_type.directives)
-        print_string(" = #{union_type.types.map(&:name).join(" | ")}")
+        print_string(" = ")
+        i = 0
+        union_type.types.each do |t|
+          if i > 0
+            print_string(" | ")
+          end
+          print_string(t.name)
+          i += 1
+        end
       end
 
       def print_enum_type_definition(enum_type, extension: false)
         extension ? print_string("extend ") : print_description(enum_type)
-        print_string("enum #{enum_type.name}")
+        print_string("enum ")
+        print_string(enum_type.name)
         print_directives(enum_type.directives)
         print_string(" {\n")
         enum_type.values.each.with_index do |value, i|
@@ -316,14 +362,16 @@ module GraphQL
       end
 
       def print_enum_value_definition(enum_value)
-        print_string("  #{enum_value.name}")
+        print_string("  ")
+        print_string(enum_value.name)
         print_directives(enum_value.directives)
         print_string("\n")
       end
 
       def print_input_object_type_definition(input_object_type, extension: false)
         extension ? print_string("extend ") : print_description(input_object_type)
-        print_string("input #{input_object_type.name}")
+        print_string("input ")
+        print_string(input_object_type.name)
         print_directives(input_object_type.directives)
         if !input_object_type.fields.empty?
           print_string(" {\n")
@@ -339,7 +387,8 @@ module GraphQL
 
       def print_directive_definition(directive)
         print_description(directive)
-        print_string("directive @#{directive.name}")
+        print_string("directive @")
+        print_string(directive.name)
 
         if directive.arguments.any?
           print_arguments(directive.arguments)
@@ -349,7 +398,15 @@ module GraphQL
           print_string(" repeatable")
         end
 
-        print_string(" on #{directive.locations.map(&:name).join(" | ")}")
+        print_string(" on ")
+        i = 0
+        directive.locations.each do |loc|
+          if i > 0
+            print_string(" | ")
+          end
+          print_string(loc.name)
+          i += 1
+        end
       end
 
       def print_description(node, indent: "", first_in_block: true)
@@ -363,11 +420,13 @@ module GraphQL
         return if fields.empty?
 
         print_string(" {\n")
-        fields.each.with_index do |field, i|
+        i = 0
+        fields.each do |field|
           print_description(field, indent: "  ", first_in_block: i == 0)
           print_string("  ")
           print_field_definition(field)
           print_string("\n")
+          i += 1
         end
         print_string("}")
       end
@@ -389,7 +448,8 @@ module GraphQL
           print_node(selection, indent: indent + "  ")
           print_string("\n")
         end
-        print_string("#{indent}}")
+        print_string(indent)
+        print_string("}")
       end
 
       def print_node(node, indent: "")
@@ -474,7 +534,8 @@ module GraphQL
         when Hash
           print_string("{")
           node.each_with_index do |(k, v), i|
-            print_string("#{k}: ")
+            print_string(k)
+            print_string(": ")
             print_node(v)
             print_string(", ") if i < node.length - 1
           end

data/lib/graphql/language/sanitized_printer.rb

@@ -203,7 +203,12 @@ module GraphQL
             [value].map { |v| value_to_ast(v, type.of_type) }
           end
         when "ENUM"
-          GraphQL::Language::Nodes::Enum.new(name: value)
+          if value.is_a?(GraphQL::Language::Nodes::Enum)
+            # if it was a default value, it's already wrapped
+            value
+          else
+            GraphQL::Language::Nodes::Enum.new(name: value)
+          end
         else
           value
         end

data/lib/graphql/language/static_visitor.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+module GraphQL
+  module Language
+    # Like `GraphQL::Language::Visitor` except it doesn't support
+    # making changes to the document -- only visiting it as-is.
+    class StaticVisitor
+      def initialize(document)
+        @document = document
+      end
+
+      # Visit `document` and all children
+      # @return [void]
+      def visit
+        # `@document` may be any kind of node:
+        visit_method = @document.visit_method
+        result = public_send(visit_method, @document, nil)
+        @result = if result.is_a?(Array)
+          result.first
+        else
+          # The node wasn't modified
+          @document
+        end
+      end
+
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # The default implementation for visiting an AST node.
+          # It doesn't _do_ anything, but it continues to visiting the node's children.
+          # To customize this hook, override one of its make_visit_methods (or the base method?)
+          # in your subclasses.
+          #
+          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+          # @return [void]
+          def #{node_method}(node, parent)
+            #{
+              if method_defined?(child_visit_method)
+                "#{child_visit_method}(node)"
+              elsif children_of_type
+                children_of_type.map do |child_accessor, child_class|
+                  "node.#{child_accessor}.each do |child_node|
+                    #{child_class.visit_method}(child_node, node)
+                  end"
+                end.join("\n")
+              else
+                ""
+              end
+            }
+          end
+        RUBY
+      end
+
+      def on_document_children(document_node)
+        document_node.children.each do |child_node|
+          visit_method = child_node.visit_method
+          public_send(visit_method, child_node, document_node)
+        end
+      end
+
+      def on_field_children(new_node)
+        new_node.arguments.each do |arg_node| # rubocop:disable Development/ContextIsPassedCop
+          on_argument(arg_node, new_node)
+        end
+        visit_directives(new_node)
+        visit_selections(new_node)
+      end
+
+      def visit_directives(new_node)
+        new_node.directives.each do |dir_node|
+          on_directive(dir_node, new_node)
+        end
+      end
+
+      def visit_selections(new_node)
+        new_node.selections.each do |selection|
+          case selection
+          when GraphQL::Language::Nodes::Field
+            on_field(selection, new_node)
+          when GraphQL::Language::Nodes::InlineFragment
+            on_inline_fragment(selection, new_node)
+          when GraphQL::Language::Nodes::FragmentSpread
+            on_fragment_spread(selection, new_node)
+          else
+            raise ArgumentError, "Invariant: unexpected field selection #{selection.class} (#{selection.inspect})"
+          end
+        end
+      end
+
+      def on_fragment_definition_children(new_node)
+        visit_directives(new_node)
+        visit_selections(new_node)
+      end
+
+      alias :on_inline_fragment_children :on_fragment_definition_children
+
+      def on_operation_definition_children(new_node)
+        new_node.variables.each do |arg_node|
+          on_variable_definition(arg_node, new_node)
+        end
+        visit_directives(new_node)
+        visit_selections(new_node)
+      end
+
+      def on_argument_children(new_node)
+        new_node.children.each do |value_node|
+          case value_node
+          when Language::Nodes::VariableIdentifier
+            on_variable_identifier(value_node, new_node)
+          when Language::Nodes::InputObject
+            on_input_object(value_node, new_node)
+          when Language::Nodes::Enum
+            on_enum(value_node, new_node)
+          when Language::Nodes::NullValue
+            on_null_value(value_node, new_node)
+          else
+            raise ArgumentError, "Invariant: unexpected argument value node #{value_node.class} (#{value_node.inspect})"
+          end
+        end
+      end
+
+      [
+        Language::Nodes::Argument,
+        Language::Nodes::Directive,
+        Language::Nodes::DirectiveDefinition,
+        Language::Nodes::DirectiveLocation,
+        Language::Nodes::Document,
+        Language::Nodes::Enum,
+        Language::Nodes::EnumTypeDefinition,
+        Language::Nodes::EnumTypeExtension,
+        Language::Nodes::EnumValueDefinition,
+        Language::Nodes::Field,
+        Language::Nodes::FieldDefinition,
+        Language::Nodes::FragmentDefinition,
+        Language::Nodes::FragmentSpread,
+        Language::Nodes::InlineFragment,
+        Language::Nodes::InputObject,
+        Language::Nodes::InputObjectTypeDefinition,
+        Language::Nodes::InputObjectTypeExtension,
+        Language::Nodes::InputValueDefinition,
+        Language::Nodes::InterfaceTypeDefinition,
+        Language::Nodes::InterfaceTypeExtension,
+        Language::Nodes::ListType,
+        Language::Nodes::NonNullType,
+        Language::Nodes::NullValue,
+        Language::Nodes::ObjectTypeDefinition,
+        Language::Nodes::ObjectTypeExtension,
+        Language::Nodes::OperationDefinition,
+        Language::Nodes::ScalarTypeDefinition,
+        Language::Nodes::ScalarTypeExtension,
+        Language::Nodes::SchemaDefinition,
+        Language::Nodes::SchemaExtension,
+        Language::Nodes::TypeName,
+        Language::Nodes::UnionTypeDefinition,
+        Language::Nodes::UnionTypeExtension,
+        Language::Nodes::VariableDefinition,
+        Language::Nodes::VariableIdentifier,
+      ].each do |ast_node_class|
+        make_visit_methods(ast_node_class)
+      end
+    end
+  end
+end

data/lib/graphql/language/visitor.rb

@@ -30,6 +30,8 @@ module GraphQL
     #   # Check the result
     #   visitor.count
     #   # => 3
+    #
+    # @see GraphQL::Language::StaticVisitor for a faster visitor that doesn't support modifying the document
     class Visitor
       class DeleteNode; end
 

data/lib/graphql/language.rb

@@ -8,6 +8,7 @@ require "graphql/language/lexer"
 require "graphql/language/nodes"
 require "graphql/language/cache"
 require "graphql/language/parser"
+require "graphql/language/static_visitor"
 require "graphql/language/token"
 require "graphql/language/visitor"
 require "graphql/language/definition_slice"