graphql 2.0.26 → 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

@@ -14,7 +14,7 @@ module GraphQL
     # @param include_built_in_directives [Boolean] Whether or not to include built in directives in the AST
     class DocumentFromSchemaDefinition
       def initialize(
-        schema, context: nil, only: nil, except: nil, include_introspection_types: false,
+        schema, context: nil, include_introspection_types: false,
         include_built_in_directives: false, include_built_in_scalars: false, always_include_schema: false
       )
         @schema = schema
@@ -26,21 +26,11 @@ module GraphQL
 
         schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
 
-        @warden = if only || except
-          filter = GraphQL::Filter
-            .new(only: only, except: except)
-            .merge(only: @schema.method(:visible?))
-          GraphQL::Schema::Warden.new(
-              filter,
-              schema: @schema,
-              context: schema_context,
-            )
-        else
-          @schema.warden_class.new(
-            schema: @schema,
-            context: schema_context,
-          )
-        end
+
+        @warden = @schema.warden_class.new(
+          schema: @schema,
+          context: schema_context,
+        )
 
         schema_context.warden = @warden
       end
@@ -52,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),
@@ -190,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
 
@@ -247,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)
@@ -263,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
@@ -295,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
@@ -320,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/lexer.rb

@@ -4,7 +4,7 @@ require "strscan"
 
 module GraphQL
   module Language
-    module Lexer
+    class Lexer
       IDENTIFIER =    /[_A-Za-z][_0-9A-Za-z]*/
       NEWLINE =       /[\c\r\n]/
       BLANK   =       /[, \t]+/
@@ -87,60 +87,81 @@ module GraphQL
       # # catch-all for anything else. must be at the bottom for precedence.
       UNKNOWN_CHAR =         /./
 
-      def self.tokenize string
-        meta = {
-          line: 1,
-          col: 1,
-          tokens: [],
-          previous_token: nil,
-        }
+      def initialize(value)
+        @line = 1
+        @col = 1
+        @previous_token = nil
 
+        @scan = scanner value
+      end
+
+      class BadEncoding < Lexer # :nodoc:
+        def scanner(value)
+          [emit(:BAD_UNICODE_ESCAPE, 0, 0, value)]
+        end
+
+        def next_token
+          @scan.pop
+        end
+      end
+
+      def self.tokenize(string)
         value = string.dup.force_encoding(Encoding::UTF_8)
 
-        unless value.valid_encoding?
-          emit(:BAD_UNICODE_ESCAPE, 0, 0, meta, value)
-          return meta[:tokens]
+        scanner = if value.valid_encoding?
+          new value
+        else
+          BadEncoding.new value
         end
 
-        scan = StringScanner.new value
-
-        while !scan.eos?
-          pos = scan.pos
-
-          case
-          when str = scan.scan(FLOAT)         then emit(:FLOAT, pos, scan.pos, meta, str)
-          when str = scan.scan(INT)           then emit(:INT, pos, scan.pos, meta, str)
-          when str = scan.scan(LIT)           then emit(LIT_NAME_LUT[str], pos, scan.pos, meta, -str)
-          when str = scan.scan(IDENTIFIER)    then emit(:IDENTIFIER, pos, scan.pos, meta, str)
-          when str = scan.scan(BLOCK_STRING)  then emit_block(pos, scan.pos, meta, str.gsub(/^#{BLOCK_QUOTE}|#{BLOCK_QUOTE}$/, ''))
-          when str = scan.scan(QUOTED_STRING) then emit_string(pos, scan.pos, meta, str.gsub(/^"|"$/, ''))
-          when str = scan.scan(COMMENT)       then record_comment(pos, scan.pos, meta, str)
-          when str = scan.scan(NEWLINE)
-            meta[:line] += 1
-            meta[:col] = 1
-          when scan.scan(BLANK)
-            meta[:col] += scan.pos - pos
-          when str = scan.scan(UNKNOWN_CHAR) then emit(:UNKNOWN_CHAR, pos, scan.pos, meta, str)
-          else
-            # This should never happen since `UNKNOWN_CHAR` ensures we make progress
-            raise "Unknown string?"
-          end
+        toks = []
+
+        while tok = scanner.next_token
+          toks << tok
         end
 
-        meta[:tokens]
+        toks
+      end
+
+      def next_token
+        return if @scan.eos?
+
+        pos = @scan.pos
+
+        case
+        when str = @scan.scan(FLOAT)         then emit(:FLOAT, pos, @scan.pos, str)
+        when str = @scan.scan(INT)           then emit(:INT, pos, @scan.pos, str)
+        when str = @scan.scan(LIT)           then emit(LIT_NAME_LUT[str], pos, @scan.pos, -str)
+        when str = @scan.scan(IDENTIFIER)    then emit(:IDENTIFIER, pos, @scan.pos, str)
+        when str = @scan.scan(BLOCK_STRING)  then emit_block(pos, @scan.pos, str.gsub(/\A#{BLOCK_QUOTE}|#{BLOCK_QUOTE}\z/, ''))
+        when str = @scan.scan(QUOTED_STRING) then emit_string(pos, @scan.pos, str.gsub(/^"|"$/, ''))
+        when str = @scan.scan(COMMENT)       then record_comment(pos, @scan.pos, str)
+        when str = @scan.scan(NEWLINE)
+          @line += 1
+          @col = 1
+          next_token
+        when @scan.scan(BLANK)
+          @col += @scan.pos - pos
+          next_token
+        when str = @scan.scan(UNKNOWN_CHAR) then emit(:UNKNOWN_CHAR, pos, @scan.pos, str)
+        else
+          # This should never happen since `UNKNOWN_CHAR` ensures we make progress
+          raise "Unknown string?"
+        end
       end
 
-      def self.emit(token_name, ts, te, meta, token_value)
-        meta[:tokens] << token = [
+      def emit(token_name, ts, te, token_value)
+        token = [
           token_name,
-          meta[:line],
-          meta[:col],
+          @line,
+          @col,
           token_value,
-          meta[:previous_token],
+          @previous_token,
         ]
-        meta[:previous_token] = token
+        @previous_token = token
         # Bump the column counter for the next token
-        meta[:col] += te - ts
+        @col += te - ts
+        token
       end
 
       # Replace any escaped unicode or whitespace with the _actual_ characters
@@ -169,18 +190,19 @@ module GraphQL
         nil
       end
 
-      def self.record_comment(ts, te, meta, str)
+      def record_comment(ts, te, str)
         token = [
           :COMMENT,
-          meta[:line],
-          meta[:col],
+          @line,
+          @col,
           str,
-          meta[:previous_token],
+          @previous_token,
         ]
 
-        meta[:previous_token] = token
+        @previous_token = token
 
-        meta[:col] += te - ts
+        @col += te - ts
+        next_token
       end
 
       ESCAPES = /\\["\\\/bfnrt]/
@@ -197,26 +219,34 @@ module GraphQL
       UTF_8 = /\\u(?:([\dAa-f]{4})|\{([\da-f]{4,})\})(?:\\u([\dAa-f]{4}))?/i
       VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{UTF_8})*\z/o
 
-      def self.emit_block(ts, te, meta, value)
+      def emit_block(ts, te, value)
         line_incr = value.count("\n")
         value = GraphQL::Language::BlockString.trim_whitespace(value)
-        emit_string(ts, te, meta, value)
-        meta[:line] += line_incr
+        tok = emit_string(ts, te, value)
+        @line += line_incr
+        tok
       end
 
-      def self.emit_string(ts, te, meta, value)
+      def emit_string(ts, te, value)
         if !value.valid_encoding? || !value.match?(VALID_STRING)
-          emit(:BAD_UNICODE_ESCAPE, ts, te, meta, value)
+          emit(:BAD_UNICODE_ESCAPE, ts, te, value)
         else
-          replace_escaped_characters_in_place(value)
+          self.class.replace_escaped_characters_in_place(value)
 
           if !value.valid_encoding?
-            emit(:BAD_UNICODE_ESCAPE, ts, te, meta, value)
+            emit(:BAD_UNICODE_ESCAPE, ts, te, value)
           else
-            emit(:STRING, ts, te, meta, value)
+            emit(:STRING, ts, te, value)
           end
         end
       end
+
+      private
+
+      def scanner(value)
+        StringScanner.new value
+      end
+
     end
   end
 end

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
 
@@ -535,7 +535,7 @@ module GraphQL
       # @example Creating a custom string from a document
       #  class VariableScrubber < GraphQL::Language::Printer
       #    def print_argument(arg)
-      #      "#{arg.name}: <HIDDEN>"
+      #      print_string("#{arg.name}: <HIDDEN>")
       #    end
       #  end
       #