graphql 1.7.14 → 1.8.0.pre1

data/lib/graphql/language/lexer.rl

@@ -34,9 +34,6 @@
   RBRACKET =      ']';
   COLON =         ':';
   QUOTE =         '"';
-  BLOCK_QUOTE =   '"""';
-  ESCAPED_BLOCK_QUOTE = '\\"""';
-  BLOCK_STRING_CHAR = (ESCAPED_BLOCK_QUOTE | ^'"""');
   ESCAPED_QUOTE = '\\"';
   STRING_CHAR =   (ESCAPED_QUOTE | ^'"');
   VAR_SIGN =      '$';
@@ -45,10 +42,9 @@
   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 =         /./;
 
@@ -79,15 +75,13 @@
     RBRACKET      => { emit(:RBRACKET, ts, te, meta) };
     LBRACKET      => { emit(:LBRACKET, ts, te, meta) };
     COLON         => { emit(:COLON, ts, te, meta) };
-    QUOTED_STRING => { emit_string(ts, te, meta, block: false) };
-    BLOCK_STRING  => { emit_string(ts, te, meta, block: true) };
+    QUOTED_STRING => { emit_string(ts + 1, te - 1, meta) };
     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) };
 
@@ -194,13 +188,8 @@ module GraphQL
       PACK_DIRECTIVE = "c*"
       UTF_8_ENCODING = "UTF-8"
 
-      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
+      def self.emit_string(ts, te, meta)
+        value = meta[:data][ts...te].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
         if value !~ VALID_STRING
           meta[:tokens] << token = GraphQL::Language::Token.new(
             name: :BAD_UNICODE_ESCAPE,

data/lib/graphql/language/nodes.rb

@@ -8,16 +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
-        module Scalars # :nodoc:
-          module Name
-            def scalars
-              super + [name]
-            end
-          end
-        end
-
         attr_accessor :line, :col, :filename
 
         # Initialize a node by extracting its position,
@@ -50,50 +41,79 @@ 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(printer: GraphQL::Language::Printer.new)
-          printer.print(self)
+        def to_query_string
+          Generation.generate(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 scalars
-          [of_type]
+        def children
+          [].freeze
         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
@@ -106,20 +126,15 @@ 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
-        alias :children :arguments
+        scalar_attributes :name
+        child_attributes :arguments
 
         def initialize_node(name: nil, arguments: [])
           @name = name
@@ -128,9 +143,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
@@ -138,10 +153,6 @@ module GraphQL
           @locations = locations
           @description = description
         end
-
-        def children
-          arguments + locations
-        end
       end
 
       # This is the AST root for normal queries
@@ -153,18 +164,9 @@ 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
-        alias :children :definitions
+        child_attributes :definitions
 
         # @!attribute definitions
         #   @return [Array<OperationDefinition, FragmentDefinition>] top-level GraphQL units: operations or fragments
@@ -186,6 +188,8 @@ 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)
@@ -198,19 +202,13 @@ 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}`
@@ -223,22 +221,13 @@ 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
-        alias :children :directives
+        scalar_attributes :name
+        child_attributes :directives
 
         # @!attribute name
         #   @return [String] The identifier of the fragment to apply, corresponds with {FragmentDefinition#name}
@@ -252,6 +241,8 @@ 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
@@ -261,20 +252,12 @@ 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
-        alias :children :arguments
+        child_attributes :arguments
 
         # @!attribute arguments
         #   @return [Array<Nodes::Argument>] A list of key-value pairs inside this input object
@@ -295,16 +278,13 @@ module GraphQL
         private
 
         def serialize_value_for_hash(value)
-          case value
-          when InputObject
+          if value.is_a? InputObject
             value.to_h
-          when Array
+          elsif value.is_a? Array
             value.map do |v|
               serialize_value_for_hash v
             end
-          when Enum
-            value.name
-          when NullValue
+          elsif value.is_a? NullValue
             nil
           else
             value
@@ -324,6 +304,8 @@ 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
@@ -344,14 +326,6 @@ 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
@@ -360,6 +334,7 @@ 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
@@ -375,10 +350,6 @@ 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 `$`.
@@ -386,23 +357,19 @@ module GraphQL
 
       class SchemaDefinition < AbstractNode
         attr_accessor :query, :mutation, :subscription
+        scalar_attributes :query, :mutation, :subscription
 
         def initialize_node(query: nil, mutation: nil, subscription: nil)
           @query = query
           @mutation = mutation
           @subscription = subscription
         end
-
-        def scalars
-          [query, mutation, subscription]
-        end
       end
 
       class ScalarTypeDefinition < AbstractNode
-        include Scalars::Name
-
         attr_accessor :name, :directives, :description
-        alias :children :directives
+        scalar_attributes :name
+        child_attributes :directives
 
         def initialize_node(name:, directives: [], description: nil)
           @name = name
@@ -412,9 +379,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
@@ -423,15 +390,12 @@ 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
-        alias :children :directives
+        scalar_attributes :name, :type, :default_value
+        child_attributes :directives
 
         def initialize_node(name:, type:, default_value: nil, directives: [], description: nil)
           @name = name
@@ -440,14 +404,12 @@ 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
@@ -456,20 +418,12 @@ 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
@@ -477,16 +431,12 @@ 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
@@ -494,16 +444,12 @@ 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
@@ -511,17 +457,12 @@ module GraphQL
           @directives = directives
           @description = description
         end
-
-        def children
-          values + directives
-        end
       end
 
       class EnumValueDefinition < AbstractNode
-        include Scalars::Name
-
         attr_accessor :name, :directives, :description
-        alias :children :directives
+        scalar_attributes :name
+        child_attributes :directives
 
         def initialize_node(name:, directives: [], description: nil)
           @name = name
@@ -531,10 +472,9 @@ module GraphQL
       end
 
       class InputObjectTypeDefinition < AbstractNode
-        include Scalars::Name
-
         attr_accessor :name, :fields, :directives, :description
-        alias :children :fields
+        scalar_attributes :name
+        child_attributes :fields
 
         def initialize_node(name:, fields:, directives: [], description: nil)
           @name = name