graphql 1.7.6 → 1.8.0

data/lib/graphql/language/lexer.rl

@@ -34,6 +34,9 @@
   RBRACKET =      ']';
   COLON =         ':';
   QUOTE =         '"';
+  BLOCK_QUOTE =   '"""';
+  ESCAPED_BLOCK_QUOTE = '\\"""';
+  BLOCK_STRING_CHAR = (ESCAPED_BLOCK_QUOTE | ^'"""');
   ESCAPED_QUOTE = '\\"';
   STRING_CHAR =   (ESCAPED_QUOTE | ^'"');
   VAR_SIGN =      '$';
@@ -42,9 +45,10 @@
   EQUALS =        '=';
   BANG =          '!';
   PIPE =          '|';
+  AMP =           '&';
 
   QUOTED_STRING = QUOTE STRING_CHAR* QUOTE;
-
+  BLOCK_STRING = BLOCK_QUOTE BLOCK_STRING_CHAR* BLOCK_QUOTE;
   # catch-all for anything else. must be at the bottom for precedence.
   UNKNOWN_CHAR =         /./;
 
@@ -75,13 +79,15 @@
     RBRACKET      => { emit(:RBRACKET, ts, te, meta) };
     LBRACKET      => { emit(:LBRACKET, ts, te, meta) };
     COLON         => { emit(:COLON, ts, te, meta) };
-    QUOTED_STRING => { emit_string(ts + 1, te - 1, meta) };
+    QUOTED_STRING => { emit_string(ts, te, meta, block: false) };
+    BLOCK_STRING  => { emit_string(ts, te, meta, block: true) };
     VAR_SIGN      => { emit(:VAR_SIGN, ts, te, meta) };
     DIR_SIGN      => { emit(:DIR_SIGN, ts, te, meta) };
     ELLIPSIS      => { emit(:ELLIPSIS, ts, te, meta) };
     EQUALS        => { emit(:EQUALS, ts, te, meta) };
     BANG          => { emit(:BANG, ts, te, meta) };
     PIPE          => { emit(:PIPE, ts, te, meta) };
+    AMP           => { emit(:AMP, ts, te, meta) };
     IDENTIFIER    => { emit(:IDENTIFIER, ts, te, meta) };
     COMMENT       => { record_comment(ts, te, meta) };
 
@@ -188,8 +194,13 @@ module GraphQL
       PACK_DIRECTIVE = "c*"
       UTF_8_ENCODING = "UTF-8"
 
-      def self.emit_string(ts, te, meta)
-        value = meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+      def self.emit_string(ts, te, meta, block:)
+        quotes_length = block ? 3 : 1
+        ts += quotes_length
+        value = meta[:data][ts...te - quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
+        if block
+          value = GraphQL::Language::BlockString.trim_whitespace(value)
+        end
         if value !~ VALID_STRING
           meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,

data/lib/graphql/language/nodes.rb

@@ -8,7 +8,16 @@ 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
+        module Scalars # :nodoc:
+          module Name
+            def scalars
+              super + [name]
+            end
+          end
+        end
+
         attr_accessor :line, :col, :filename
 
         # Initialize a node by extracting its position,
@@ -41,79 +50,50 @@ module GraphQL
 
         # @return [Array<GraphQL::Language::Nodes::AbstractNode>] all nodes in the tree below this one
         def children
-          self.class.child_attributes
-            .map { |attr_name| public_send(attr_name) }
-            .flatten
+          []
         end
 
         # @return [Array<Integer, Float, String, Boolean, Array>] Scalar values attached to this node
         def scalars
-          self.class.scalar_attributes
-            .map { |attr_name| public_send(attr_name) }
-        end
-
-        class << self
-          # A node subclass inherits `scalar_attributes`
-          # and `child_attributes` from its parent
-          def inherited(subclass)
-            subclass.scalar_attributes(*@scalar_attributes)
-            subclass.child_attributes(*@child_attributes)
-          end
-
-          # define `attr_names` as places where scalars may be attached to this node
-          def scalar_attributes(*attr_names)
-            @scalar_attributes ||= []
-            @scalar_attributes += attr_names
-          end
-
-          # define `attr_names` as places where child nodes may be attached to this node
-          def child_attributes(*attr_names)
-            @child_attributes ||= []
-            @child_attributes += attr_names
-          end
+          []
         end
 
         def position
           [line, col]
         end
 
-        def to_query_string
-          Generation.generate(self)
+        def to_query_string(printer: GraphQL::Language::Printer.new)
+          printer.print(self)
         end
       end
 
       # Base class for non-null type names and list type names
       class WrapperType < AbstractNode
         attr_accessor :of_type
-        scalar_attributes :of_type
 
         def initialize_node(of_type: nil)
           @of_type = of_type
         end
 
-        def children
-          [].freeze
+        def scalars
+          [of_type]
         end
       end
 
       # Base class for nodes whose only value is a name (no child nodes or other scalars)
       class NameOnlyNode < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name
-        scalar_attributes :name
 
         def initialize_node(name: nil)
           @name = name
         end
-
-        def children
-          [].freeze
-        end
       end
 
       # A key-value pair for a field's inputs
       class Argument < AbstractNode
         attr_accessor :name, :value
-        scalar_attributes :name, :value
 
         # @!attribute name
         #   @return [String] the key for this argument
@@ -126,15 +106,20 @@ module GraphQL
           @value = value
         end
 
+        def scalars
+          [name, value]
+        end
+
         def children
           [value].flatten.select { |v| v.is_a?(AbstractNode) }
         end
       end
 
       class Directive < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :arguments
-        scalar_attributes :name
-        child_attributes :arguments
+        alias :children :arguments
 
         def initialize_node(name: nil, arguments: [])
           @name = name
@@ -143,9 +128,9 @@ module GraphQL
       end
 
       class DirectiveDefinition < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :arguments, :locations, :description
-        scalar_attributes :name
-        child_attributes :arguments, :locations
 
         def initialize_node(name: nil, arguments: [], locations: [], description: nil)
           @name = name
@@ -153,6 +138,10 @@ module GraphQL
           @locations = locations
           @description = description
         end
+
+        def children
+          arguments + locations
+        end
       end
 
       # This is the AST root for normal queries
@@ -164,9 +153,18 @@ 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
+        alias :children :definitions
 
         # @!attribute definitions
         #   @return [Array<OperationDefinition, FragmentDefinition>] top-level GraphQL units: operations or fragments
@@ -188,8 +186,6 @@ module GraphQL
       # A single selection in a GraphQL query.
       class Field < AbstractNode
         attr_accessor :name, :alias, :arguments, :directives, :selections
-        scalar_attributes :name, :alias
-        child_attributes :arguments, :directives, :selections
 
         # @!attribute selections
         #   @return [Array<Nodes::Field>] Selections on this object (or empty array if this is a scalar field)
@@ -202,13 +198,19 @@ module GraphQL
           @directives = directives
           @selections = selections
         end
+
+        def scalars
+          [name, self.alias]
+        end
+
+        def children
+          arguments + directives + selections
+        end
       end
 
       # A reusable fragment, defined at document-level.
       class FragmentDefinition < AbstractNode
         attr_accessor :name, :type, :directives, :selections
-        scalar_attributes :name, :type
-        child_attributes :directives, :selections
 
         # @!attribute name
         #   @return [String] the identifier for this fragment, which may be applied with `...#{name}`
@@ -221,13 +223,22 @@ module GraphQL
           @directives = directives
           @selections = selections
         end
+
+        def children
+          directives + selections
+        end
+
+        def scalars
+          [name, type]
+        end
       end
 
       # Application of a named fragment in a selection
       class FragmentSpread < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :directives
-        scalar_attributes :name
-        child_attributes :directives
+        alias :children :directives
 
         # @!attribute name
         #   @return [String] The identifier of the fragment to apply, corresponds with {FragmentDefinition#name}
@@ -241,8 +252,6 @@ module GraphQL
       # An unnamed fragment, defined directly in the query with `... {  }`
       class InlineFragment < AbstractNode
         attr_accessor :type, :directives, :selections
-        scalar_attributes :type
-        child_attributes :directives, :selections
 
         # @!attribute type
         #   @return [String, nil] Name of the type this fragment applies to, or `nil` if this fragment applies to any type
@@ -252,12 +261,20 @@ module GraphQL
           @directives = directives
           @selections = selections
         end
+
+        def children
+          directives + selections
+        end
+
+        def scalars
+          [type]
+        end
       end
 
       # A collection of key-value inputs which may be a field argument
       class InputObject < AbstractNode
         attr_accessor :arguments
-        child_attributes :arguments
+        alias :children :arguments
 
         # @!attribute arguments
         #   @return [Array<Nodes::Argument>] A list of key-value pairs inside this input object
@@ -278,13 +295,16 @@ module GraphQL
         private
 
         def serialize_value_for_hash(value)
-          if value.is_a? InputObject
+          case value
+          when InputObject
             value.to_h
-          elsif value.is_a? Array
+          when Array
             value.map do |v|
               serialize_value_for_hash v
             end
-          elsif value.is_a? NullValue
+          when Enum
+            value.name
+          when NullValue
             nil
           else
             value
@@ -304,8 +324,6 @@ module GraphQL
       # May be explicitly typed (eg `mutation { ... }`) or implicitly a query (eg `{ ... }`).
       class OperationDefinition < AbstractNode
         attr_accessor :operation_type, :name, :variables, :directives, :selections
-        scalar_attributes :operation_type, :name
-        child_attributes :variables, :directives, :selections
 
         # @!attribute variables
         #   @return [Array<VariableDefinition>] Variable definitions for this operation
@@ -326,6 +344,14 @@ module GraphQL
           @directives = directives
           @selections = selections
         end
+
+        def children
+          variables + directives + selections
+        end
+
+        def scalars
+          [operation_type, name]
+        end
       end
 
       # A type name, used for variable definitions
@@ -334,7 +360,6 @@ module GraphQL
       # An operation-level query variable
       class VariableDefinition < AbstractNode
         attr_accessor :name, :type, :default_value
-        scalar_attributes :name, :type, :default_value
 
         # @!attribute default_value
         #   @return [String, Integer, Float, Boolean, Array, NullValue] A Ruby value to use if no other value is provided
@@ -350,26 +375,37 @@ module GraphQL
           @type = type
           @default_value = default_value
         end
+
+        def scalars
+          [name, type, default_value]
+        end
       end
 
       # Usage of a variable in a query. Name does _not_ include `$`.
       class VariableIdentifier < NameOnlyNode; end
 
       class SchemaDefinition < AbstractNode
-        attr_accessor :query, :mutation, :subscription
-        scalar_attributes :query, :mutation, :subscription
+        attr_accessor :query, :mutation, :subscription, :directives
 
-        def initialize_node(query: nil, mutation: nil, subscription: nil)
+        def initialize_node(query: nil, mutation: nil, subscription: nil, directives: [])
           @query = query
           @mutation = mutation
           @subscription = subscription
+          @directives = directives
+        end
+
+        def scalars
+          [query, mutation, subscription]
         end
+
+        alias :children :directives
       end
 
       class ScalarTypeDefinition < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :directives, :description
-        scalar_attributes :name
-        child_attributes :directives
+        alias :children :directives
 
         def initialize_node(name:, directives: [], description: nil)
           @name = name
@@ -379,9 +415,9 @@ module GraphQL
       end
 
       class ObjectTypeDefinition < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :interfaces, :fields, :directives, :description
-        scalar_attributes :name
-        child_attributes :interfaces, :fields, :directives
 
         def initialize_node(name:, interfaces:, fields:, directives: [], description: nil)
           @name = name
@@ -390,12 +426,15 @@ module GraphQL
           @fields = fields
           @description = description
         end
+
+        def children
+          interfaces + fields + directives
+        end
       end
 
       class InputValueDefinition < AbstractNode
         attr_accessor :name, :type, :default_value, :directives,:description
-        scalar_attributes :name, :type, :default_value
-        child_attributes :directives
+        alias :children :directives
 
         def initialize_node(name:, type:, default_value: nil, directives: [], description: nil)
           @name = name
@@ -404,12 +443,14 @@ module GraphQL
           @directives = directives
           @description = description
         end
+
+        def scalars
+          [name, type, default_value]
+        end
       end
 
       class FieldDefinition < AbstractNode
         attr_accessor :name, :arguments, :type, :directives, :description
-        scalar_attributes :name, :type
-        child_attributes :arguments, :directives
 
         def initialize_node(name:, arguments:, type:, directives: [], description: nil)
           @name = name
@@ -418,12 +459,20 @@ module GraphQL
           @directives = directives
           @description = description
         end
+
+        def children
+          arguments + directives
+        end
+
+        def scalars
+          [name, type]
+        end
       end
 
       class InterfaceTypeDefinition < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :fields, :directives, :description
-        scalar_attributes :name
-        child_attributes :fields, :directives
 
         def initialize_node(name:, fields:, directives: [], description: nil)
           @name = name
@@ -431,12 +480,16 @@ module GraphQL
           @directives = directives
           @description = description
         end
+
+        def children
+          fields + directives
+        end
       end
 
       class UnionTypeDefinition < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :types, :directives, :description
-        scalar_attributes :name
-        child_attributes :types, :directives
 
         def initialize_node(name:, types:, directives: [], description: nil)
           @name = name
@@ -444,12 +497,16 @@ module GraphQL
           @directives = directives
           @description = description
         end
+
+        def children
+          types + directives
+        end
       end
 
       class EnumTypeDefinition < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :values, :directives, :description
-        scalar_attributes :name
-        child_attributes :values, :directives
 
         def initialize_node(name:, values:, directives: [], description: nil)
           @name = name
@@ -457,12 +514,17 @@ module GraphQL
           @directives = directives
           @description = description
         end
+
+        def children
+          values + directives
+        end
       end
 
       class EnumValueDefinition < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :directives, :description
-        scalar_attributes :name
-        child_attributes :directives
+        alias :children :directives
 
         def initialize_node(name:, directives: [], description: nil)
           @name = name
@@ -472,9 +534,10 @@ module GraphQL
       end
 
       class InputObjectTypeDefinition < AbstractNode
+        include Scalars::Name
+
         attr_accessor :name, :fields, :directives, :description
-        scalar_attributes :name
-        child_attributes :fields
+        alias :children :fields
 
         def initialize_node(name:, fields:, directives: [], description: nil)
           @name = name