graphql 0.19.3 → 0.19.4

data/lib/graphql/introspection/typename_field.rb

@@ -7,7 +7,7 @@ module GraphQL
           name "__typename"
           description "The name of this type"
           type -> { !GraphQL::STRING_TYPE }
-          resolve -> (obj, a, c) { wrapped_type.name }
+          resolve ->(obj, a, c) { wrapped_type.name }
         end
       end
     end

data/lib/graphql/language.rb

@@ -5,3 +5,4 @@ require "graphql/language/nodes"
 require "graphql/language/parser"
 require "graphql/language/token"
 require "graphql/language/visitor"
+require "graphql/language/comments"

data/lib/graphql/language/comments.rb

@@ -0,0 +1,44 @@
+module GraphQL
+  module Language
+    module Comments
+      extend self
+
+      def commentize(description, indent: '')
+        lines = description.split("\n")
+
+        comment = ''
+
+        lines.each do |line|
+          if line == ''
+            comment << "#{indent}#\n"
+          else
+            sublines = break_line(line, 120 - indent.length)
+            sublines.each do |subline|
+              comment << "#{indent}# #{subline}\n"
+            end
+          end
+        end
+
+        comment
+      end
+
+      private
+
+      def break_line(line, length)
+        return [line] if line.length < length + 5
+
+        parts = line.split(Regexp.new("((?: |^).{15,#{length - 40}}(?= |$))"))
+        return [line] if parts.length < 4
+
+        sublines = [parts.slice!(0, 3).join]
+
+        parts.each_with_index do |part, i|
+          next if i % 2 == 1
+          sublines << "#{part[1..-1]}#{parts[i + 1]}"
+        end
+
+        sublines
+      end
+    end
+  end
+end

data/lib/graphql/language/definition_slice.rb

@@ -16,7 +16,7 @@ module GraphQL
       def find_definition_dependencies(definitions, name)
         names = Set.new([name])
         visitor = Visitor.new(definitions[name])
-        visitor[Nodes::FragmentSpread] << -> (node, parent) {
+        visitor[Nodes::FragmentSpread] << ->(node, parent) {
           if fragment = definitions[node.name]
             names.merge(find_definition_dependencies(definitions, fragment.name))
           end

data/lib/graphql/language/generation.rb

@@ -72,18 +72,26 @@ module GraphQL
         when Nodes::VariableIdentifier
           "$#{node.name}"
         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"
           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 = "scalar #{node.name}"
+          out = generate_description(node)
+          out << "scalar #{node.name}"
           out << generate_directives(node.directives)
         when Nodes::ObjectTypeDefinition
-          out = "type #{node.name}"
+          out = generate_description(node)
+          out << "type #{node.name}"
           out << generate_directives(node.directives)
-          out << " implements " << node.interfaces.join(", ") unless node.interfaces.empty?
+          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)}"
@@ -97,16 +105,20 @@ module GraphQL
           out << ": #{generate(node.type)}"
           out << generate_directives(node.directives)
         when Nodes::InterfaceTypeDefinition
-          out = "interface #{node.name}"
+          out = generate_description(node)
+          out << "interface #{node.name}"
           out << generate_directives(node.directives)
           out << generate_field_definitions(node.fields)
         when Nodes::UnionTypeDefinition
-          out = "union #{node.name}"
+          out = generate_description(node)
+          out << "union #{node.name}"
           out << generate_directives(node.directives)
-          out << " = " + node.types.join(" | ")
+          out << " = " + node.types.map(&:name).join(" | ")
         when Nodes::EnumTypeDefinition
-          out = "enum #{node.name}#{generate_directives(node.directives)} {\n"
-          node.values.each do |value|
+          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 << "}"
@@ -115,15 +127,18 @@ module GraphQL
           out << generate_directives(node.directives)
           out << "\n"
         when Nodes::InputObjectTypeDefinition
-          out = "input #{node.name}"
+          out = generate_description(node)
+          out << "input #{node.name}"
           out << generate_directives(node.directives)
           out << " {\n"
-          node.fields.each do |field|
+          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 = "directive @#{node.name}"
+          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
@@ -161,9 +176,17 @@ module GraphQL
         end
       end
 
+      def generate_description(node, indent: '', first_in_block: true)
+        return '' unless node.description
+
+        description = indent != '' && !first_in_block ? "\n" : ""
+        description << GraphQL::Language::Comments.commentize(node.description, indent: indent)
+      end
+
       def generate_field_definitions(fields)
         out = " {\n"
-        fields.each do |field|
+        fields.each.with_index do |field, i|
+          out << generate_description(field, indent: '  ', first_in_block: i == 0)
           out << "  #{generate(field)}\n"
         end
         out << "}"

data/lib/graphql/language/lexer.rb

@@ -333,7 +333,7 @@ self._graphql_lexer_trans_actions = [
 	25, 17, 15, 117, 0, 0, 0, 0, 
 	0, 0, 0, 0, 0, 0, 0, 9, 
 	33, 7, 57, 117, 117, 37, 0, 0, 
-	0, 45, 21, 0, 0, 47, 47, 0, 
+	0, 47, 21, 0, 0, 45, 45, 0, 
 	57, 57, 49, 0, 0, 0, 0, 0, 
 	0, 39, 0, 41, 0, 0, 0, 0, 
 	60, 41, 0, 0, 0, 0, 0, 57, 
@@ -400,7 +400,7 @@ self._graphql_lexer_trans_actions = [
 	117, 43, 117, 0, 117, 117, 117, 43, 
 	117, 0, 117, 117, 117, 43, 117, 102, 
 	117, 117, 117, 43, 55, 55, 55, 51, 
-	55, 53, 45, 55, 47, 49, 39, 41, 
+	55, 53, 47, 55, 45, 49, 39, 41, 
 	41, 39, 49, 55, 43, 43, 43, 43, 
 	43, 43, 43, 43, 43, 43, 43, 43, 
 	43, 43, 43, 43, 43, 43, 43, 43, 
@@ -519,7 +519,7 @@ end
 
 # line 132 "lib/graphql/language/lexer.rl"
 
-        emit_token = -> (name) {
+        emit_token = ->(name) {
           emit(name, ts, te, meta)
         }
 
@@ -798,7 +798,7 @@ te = p+1
  begin  emit_token.call(:PIPE)  end
 		end
 when 39 then
-# line 87 "lib/graphql/language/lexer.rl"
+# line 88 "lib/graphql/language/lexer.rl"
 		begin
 te = p+1
  begin 
@@ -831,10 +831,10 @@ te = p
 p = p - 1; begin  emit_token.call(:IDENTIFIER)  end
 		end
 when 44 then
-# line 92 "lib/graphql/language/lexer.rl"
+# line 86 "lib/graphql/language/lexer.rl"
 		begin
 te = p
-p = p - 1; begin  meta[:col] += te - ts  end
+p = p - 1; begin  record_comment(ts, te, meta)  end
 		end
 when 45 then
 # line 93 "lib/graphql/language/lexer.rl"
@@ -984,13 +984,29 @@ end
         meta[:tokens]
       end
 
+      def self.record_comment(ts, te, meta)
+        token = GraphQL::Language::Token.new(
+          name: :COMMENT,
+          value: meta[:data][ts...te].pack("c*"),
+          line: meta[:line],
+          col: meta[:col],
+          prev_token: @previous_token,
+        )
+
+        @previous_token = token
+
+        meta[:col] += te - ts
+      end
+
       def self.emit(token_name, ts, te, meta)
-        meta[:tokens] << GraphQL::Language::Token.new(
+        meta[:tokens] << token = GraphQL::Language::Token.new(
           name: token_name,
           value: meta[:data][ts...te].pack("c*"),
           line: meta[:line],
           col: meta[:col],
+          prev_token: @previous_token,
         )
+        @previous_token = token
         # Bump the column counter for the next token
         meta[:col] += te - ts
       end
@@ -1008,28 +1024,31 @@ end
       }
 
       UTF_8 = /\\u[\dAa-f]{4}/i
-      UTF_8_REPLACE = -> (m) { [m[-4..-1].to_i(16)].pack('U'.freeze) }
+      UTF_8_REPLACE = ->(m) { [m[-4..-1].to_i(16)].pack('U'.freeze) }
 
       def self.emit_string(ts, te, meta)
         value = meta[:data][ts...te].pack("c*").force_encoding("UTF-8")
         if value =~ /\\u|\\./ && value !~ ESCAPES
-          meta[:tokens] << GraphQL::Language::Token.new(
+          meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,
             value: value,
             line: meta[:line],
             col: meta[:col],
+            prev_token: @previous_token,
           )
         else
           replace_escaped_characters_in_place(value)
 
-          meta[:tokens] << GraphQL::Language::Token.new(
+          meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :STRING,
             value: value,
             line: meta[:line],
             col: meta[:col],
+            prev_token: @previous_token,
           )
         end
 
+        @previous_token = token
         meta[:col] += te - ts
       end
     end

data/lib/graphql/language/lexer.rl

@@ -83,6 +83,7 @@
     BANG          => { emit_token.call(:BANG) };
     PIPE          => { emit_token.call(:PIPE) };
     IDENTIFIER    => { emit_token.call(:IDENTIFIER) };
+    COMMENT       => { record_comment(ts, te, meta) };
 
     NEWLINE => {
       meta[:line] += 1
@@ -90,7 +91,6 @@
     };
 
     BLANK   => { meta[:col] += te - ts };
-    COMMENT => { meta[:col] += te - ts };
 
     UNKNOWN_CHAR => { emit_token.call(:UNKNOWN_CHAR) };
 
@@ -130,7 +130,7 @@ module GraphQL
 
         %% write init;
 
-        emit_token = -> (name) {
+        emit_token = ->(name) {
           emit(name, ts, te, meta)
         }
 
@@ -139,13 +139,29 @@ module GraphQL
         meta[:tokens]
       end
 
+      def self.record_comment(ts, te, meta)
+        token = GraphQL::Language::Token.new(
+          name: :COMMENT,
+          value: meta[:data][ts...te].pack("c*"),
+          line: meta[:line],
+          col: meta[:col],
+          prev_token: @previous_token,
+        )
+
+        @previous_token = token
+
+        meta[:col] += te - ts
+      end
+
       def self.emit(token_name, ts, te, meta)
-        meta[:tokens] << GraphQL::Language::Token.new(
+        meta[:tokens] << token = GraphQL::Language::Token.new(
           name: token_name,
           value: meta[:data][ts...te].pack("c*"),
           line: meta[:line],
           col: meta[:col],
+          prev_token: @previous_token,
         )
+        @previous_token = token
         # Bump the column counter for the next token
         meta[:col] += te - ts
       end
@@ -163,28 +179,31 @@ module GraphQL
       }
 
       UTF_8 = /\\u[\dAa-f]{4}/i
-      UTF_8_REPLACE = -> (m) { [m[-4..-1].to_i(16)].pack('U'.freeze) }
+      UTF_8_REPLACE = ->(m) { [m[-4..-1].to_i(16)].pack('U'.freeze) }
 
       def self.emit_string(ts, te, meta)
         value = meta[:data][ts...te].pack("c*").force_encoding("UTF-8")
         if value =~ /\\u|\\./ && value !~ ESCAPES
-          meta[:tokens] << GraphQL::Language::Token.new(
+          meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,
             value: value,
             line: meta[:line],
             col: meta[:col],
+            prev_token: @previous_token,
           )
         else
           replace_escaped_characters_in_place(value)
 
-          meta[:tokens] << GraphQL::Language::Token.new(
+          meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :STRING,
             value: value,
             line: meta[:line],
             col: meta[:col],
+            prev_token: @previous_token,
           )
         end
 
+        @previous_token = token
         meta[:col] += te - ts
       end
     end

data/lib/graphql/language/nodes.rb

@@ -17,9 +17,6 @@ module GraphQL
           if options.key?(:position_source)
             position_source = options.delete(:position_source)
             @line, @col = position_source.line_and_column
-          elsif options.key?(:line)
-            @line = options.delete(:line)
-            @col = options.delete(:col)
           end
 
           initialize_node(options)
@@ -143,14 +140,15 @@ module GraphQL
       end
 
       class DirectiveDefinition < AbstractNode
-        attr_accessor :name, :arguments, :locations
+        attr_accessor :name, :arguments, :locations, :description
         scalar_attributes :name
         child_attributes :arguments, :locations
 
-        def initialize_node(name: nil, arguments: [], locations: [])
+        def initialize_node(name: nil, arguments: [], locations: [], description: nil)
           @name = name
           @arguments = arguments
           @locations = locations
+          @description = description
         end
       end
 
@@ -347,111 +345,120 @@ module GraphQL
       end
 
       class ScalarTypeDefinition < AbstractNode
-        attr_accessor :name, :directives
+        attr_accessor :name, :directives, :description
         scalar_attributes :name
         child_attributes :directives
 
-        def initialize_node(name:, directives: [])
+        def initialize_node(name:, directives: [], description: nil)
           @name = name
           @directives = directives
+          @description = description
         end
       end
 
       class ObjectTypeDefinition < AbstractNode
-        attr_accessor :name, :interfaces, :fields, :directives
+        attr_accessor :name, :interfaces, :fields, :directives, :description
         scalar_attributes :name
         child_attributes :interfaces, :fields, :directives
 
-        def initialize_node(name:, interfaces:, fields:, directives: [])
+        def initialize_node(name:, interfaces:, fields:, directives: [], description: nil)
           @name = name
           @interfaces = interfaces || []
           @directives = directives
           @fields = fields
+          @description = description
         end
       end
 
       class InputValueDefinition < AbstractNode
-        attr_accessor :name, :type, :default_value, :directives
+        attr_accessor :name, :type, :default_value, :directives,:description
         scalar_attributes :name, :type, :default_value
         child_attributes :directives
 
-        def initialize_node(name:, type:, default_value: nil, directives: [])
+        def initialize_node(name:, type:, default_value: nil, directives: [], description: nil)
           @name = name
           @type = type
           @default_value = default_value
           @directives = directives
+          @description = description
         end
       end
 
       class FieldDefinition < AbstractNode
-        attr_accessor :name, :arguments, :type, :directives
+        attr_accessor :name, :arguments, :type, :directives, :description
         scalar_attributes :name, :type
         child_attributes :arguments, :directives
 
-        def initialize_node(name:, arguments:, type:, directives: [])
+        def initialize_node(name:, arguments:, type:, directives: [], description: nil)
           @name = name
           @arguments = arguments
           @type = type
           @directives = directives
+          @description = description
         end
       end
 
       class InterfaceTypeDefinition < AbstractNode
-        attr_accessor :name, :fields, :directives
+        attr_accessor :name, :fields, :directives, :description
         scalar_attributes :name
         child_attributes :fields, :directives
 
-        def initialize_node(name:, fields:, directives: [])
+        def initialize_node(name:, fields:, directives: [], description: nil)
           @name = name
           @fields = fields
           @directives = directives
+          @description = description
         end
       end
 
       class UnionTypeDefinition < AbstractNode
-        attr_accessor :name, :types, :directives
+        attr_accessor :name, :types, :directives, :description
         scalar_attributes :name
         child_attributes :types, :directives
 
-        def initialize_node(name:, types:, directives: [])
+        def initialize_node(name:, types:, directives: [], description: nil)
           @name = name
           @types = types
           @directives = directives
+          @description = description
         end
       end
 
       class EnumTypeDefinition < AbstractNode
-        attr_accessor :name, :values, :directives
+        attr_accessor :name, :values, :directives, :description
         scalar_attributes :name
         child_attributes :values, :directives
 
-        def initialize_node(name:, values:, directives: [])
+        def initialize_node(name:, values:, directives: [], description: nil)
           @name = name
           @values = values
           @directives = directives
+          @description = description
         end
       end
 
       class EnumValueDefinition < AbstractNode
-        attr_accessor :name, :directives
+        attr_accessor :name, :directives, :description
         scalar_attributes :name
         child_attributes :directives
 
-        def initialize_node(name:, directives: [])
+        def initialize_node(name:, directives: [], description: nil)
           @name = name
           @directives = directives
+          @description = description
         end
       end
 
       class InputObjectTypeDefinition < AbstractNode
-        attr_accessor :name, :fields, :directives
+        attr_accessor :name, :fields, :directives, :description
         scalar_attributes :name
         child_attributes :fields
 
-        def initialize_node(name:, fields:, directives: [])
+        def initialize_node(name:, fields:, directives: [], description: nil)
           @name = name
           @fields = fields
           @directives = directives
+          @description = description
         end
       end
     end