graphql 1.9.17 → 2.0.20

data/lib/graphql/internal_representation/rewrite.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    # While visiting an AST, build a normalized, flattened tree of {InternalRepresentation::Node}s.
-    #
-    # No unions or interfaces are present in this tree, only object types.
-    #
-    # Selections from the AST are attached to the object types they apply to.
-    #
-    # Inline fragments and fragment spreads are preserved in {InternalRepresentation::Node#ast_spreads},
-    # where they can be used to check for the presence of directives. This might not be sufficient
-    # for future directives, since the selections' grouping is lost.
-    #
-    # The rewritten query tree serves as the basis for the `FieldsWillMerge` validation.
-    #
-    module Rewrite
-      include GraphQL::Language
-
-      NO_DIRECTIVES = [].freeze
-
-      # @return InternalRepresentation::Document
-      attr_reader :rewrite_document
-
-      def initialize(*)
-        super
-        @query = context.query
-        @rewrite_document = InternalRepresentation::Document.new
-        # Hash<Nodes::FragmentSpread => Set<InternalRepresentation::Node>>
-        # A record of fragment spreads and the irep nodes that used them
-        @rewrite_spread_parents = Hash.new { |h, k| h[k] = Set.new }
-        # Hash<Nodes::FragmentSpread => Scope>
-        @rewrite_spread_scopes = {}
-        # Array<Set<InternalRepresentation::Node>>
-        # The current point of the irep_tree during visitation
-        @rewrite_nodes_stack = []
-        # Array<Scope>
-        @rewrite_scopes_stack = []
-        @rewrite_skip_nodes = Set.new
-
-        # Resolve fragment spreads.
-        # Fragment definitions got their own irep trees during visitation.
-        # Those nodes are spliced in verbatim (not copied), but this is OK
-        # because fragments are resolved from the "bottom up", each fragment
-        # can be shared between its usages.
-        context.on_dependency_resolve do |defn_ast_node, spread_ast_nodes, frag_ast_node|
-          frag_name = frag_ast_node.name
-          fragment_node = @rewrite_document.fragment_definitions[frag_name]
-
-          if fragment_node
-            spread_ast_nodes.each do |spread_ast_node|
-              parent_nodes = @rewrite_spread_parents[spread_ast_node]
-              parent_scope = @rewrite_spread_scopes[spread_ast_node]
-              parent_nodes.each do |parent_node|
-                parent_node.deep_merge_node(fragment_node, scope: parent_scope, merge_self: false)
-              end
-            end
-          end
-        end
-      end
-
-      # @return [Hash<String, Node>] Roots of this query
-      def operations
-        warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
-        @document.operation_definitions
-      end
-
-      def on_operation_definition(ast_node, parent)
-        push_root_node(ast_node, @rewrite_document.operation_definitions) { super }
-      end
-
-      def on_fragment_definition(ast_node, parent)
-        push_root_node(ast_node, @rewrite_document.fragment_definitions) { super }
-      end
-
-      def push_root_node(ast_node, definitions)
-        # Either QueryType or the fragment type condition
-        owner_type = context.type_definition
-        defn_name = ast_node.name
-
-        node = Node.new(
-          parent: nil,
-          name: defn_name,
-          owner_type: owner_type,
-          query: @query,
-          ast_nodes: [ast_node],
-          return_type: owner_type,
-        )
-
-        definitions[defn_name] = node
-        @rewrite_scopes_stack.push(Scope.new(@query, owner_type))
-        @rewrite_nodes_stack.push([node])
-        yield
-        @rewrite_nodes_stack.pop
-        @rewrite_scopes_stack.pop
-      end
-
-      def on_inline_fragment(node, parent)
-        # Inline fragments provide two things to the rewritten tree:
-        # - They _may_ narrow the scope by their type condition
-        # - They _may_ apply their directives to their children
-        if skip?(node)
-          @rewrite_skip_nodes.add(node)
-        end
-
-        if @rewrite_skip_nodes.empty?
-          @rewrite_scopes_stack.push(@rewrite_scopes_stack.last.enter(context.type_definition))
-        end
-
-        super
-
-        if @rewrite_skip_nodes.empty?
-          @rewrite_scopes_stack.pop
-        end
-
-        if @rewrite_skip_nodes.include?(node)
-          @rewrite_skip_nodes.delete(node)
-        end
-      end
-
-      def on_field(ast_node, ast_parent)
-        if skip?(ast_node)
-          @rewrite_skip_nodes.add(ast_node)
-        end
-
-        if @rewrite_skip_nodes.empty?
-          node_name = ast_node.alias || ast_node.name
-          parent_nodes = @rewrite_nodes_stack.last
-          next_nodes = []
-
-          field_defn = context.field_definition
-          if field_defn.nil?
-            # It's a non-existent field
-            new_scope = nil
-          else
-            field_return_type = field_defn.type
-            @rewrite_scopes_stack.last.each do |scope_type|
-              parent_nodes.each do |parent_node|
-                node = parent_node.scoped_children[scope_type][node_name] ||= Node.new(
-                  parent: parent_node,
-                  name: node_name,
-                  owner_type: scope_type,
-                  query: @query,
-                  return_type: field_return_type,
-                )
-                node.ast_nodes << ast_node
-                node.definitions << field_defn
-                next_nodes << node
-              end
-            end
-            new_scope = Scope.new(@query, field_return_type.unwrap)
-          end
-
-          @rewrite_nodes_stack.push(next_nodes)
-          @rewrite_scopes_stack.push(new_scope)
-        end
-
-        super
-
-        if @rewrite_skip_nodes.empty?
-          @rewrite_nodes_stack.pop
-          @rewrite_scopes_stack.pop
-        end
-
-        if @rewrite_skip_nodes.include?(ast_node)
-          @rewrite_skip_nodes.delete(ast_node)
-        end
-      end
-
-      def on_fragment_spread(ast_node, ast_parent)
-        if @rewrite_skip_nodes.empty? && !skip?(ast_node)
-          # Register the irep nodes that depend on this AST node:
-          @rewrite_spread_parents[ast_node].merge(@rewrite_nodes_stack.last)
-          @rewrite_spread_scopes[ast_node] = @rewrite_scopes_stack.last
-        end
-        super
-      end
-
-      def skip?(ast_node)
-        dir = ast_node.directives
-        dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, @query)
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation/scope.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    # At a point in the AST, selections may apply to one or more types.
-    # {Scope} represents those types which selections may apply to.
-    #
-    # Scopes can be defined by:
-    #
-    # - A single concrete or abstract type
-    # - An array of types
-    # - `nil`
-    #
-    # The AST may be scoped to an array of types when two abstractly-typed
-    # fragments occur in inside one another.
-    class Scope
-      NO_TYPES = [].freeze
-
-      # @param query [GraphQL::Query]
-      # @param type_defn [GraphQL::BaseType, Array<GraphQL::BaseType>, nil]
-      def initialize(query, type_defn)
-        @query = query
-        @type = type_defn
-        @abstract_type = false
-        @types = case type_defn
-        when Array
-          type_defn
-        when GraphQL::BaseType
-          @abstract_type = true
-          nil
-        when nil
-          NO_TYPES
-        else
-          raise "Unexpected scope type: #{type_defn}"
-        end
-      end
-
-      # From a starting point of `self`, create a new scope by condition `other_type_defn`.
-      # @param other_type_defn [GraphQL::BaseType, nil]
-      # @return [Scope]
-      def enter(other_type_defn)
-        case other_type_defn
-        when nil
-          # The type wasn't found, who cares
-          Scope.new(@query, nil)
-        when @type
-          # The condition is the same as current, so reuse self
-          self
-        when GraphQL::UnionType, GraphQL::InterfaceType
-          # Make a new scope of the intersection between the previous & next conditions
-          new_types = @query.possible_types(other_type_defn) & concrete_types
-          Scope.new(@query, new_types)
-        when GraphQL::BaseType
-          # If this type is valid within the current scope,
-          # return a new scope of _exactly_ this type.
-          # Otherwise, this type is out-of-scope so the scope is null.
-          if concrete_types.include?(other_type_defn)
-            Scope.new(@query, other_type_defn)
-          else
-            Scope.new(@query, nil)
-          end
-        else
-          raise "Unexpected scope: #{other_type_defn.inspect}"
-        end
-      end
-
-      # Call the block for each type in `self`.
-      # This uses the simplest possible expression of `self`,
-      # so if this scope is defined by an abstract type, it gets yielded.
-      def each
-        if @abstract_type
-          yield(@type)
-        else
-          @types.each { |t| yield(t) }
-        end
-      end
-
-      private
-
-      def concrete_types
-        @concrete_types ||= if @abstract_type
-          @query.possible_types(@type)
-        else
-          @types
-        end
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation/visit.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  module InternalRepresentation
-    # Traverse a re-written query tree, calling handlers for each node
-    module Visit
-      module_function
-      def visit_each_node(operations, handlers)
-        return if handlers.empty?
-        # Post-validation: make some assertions about the rewritten query tree
-        operations.each do |op_name, op_node|
-          # Yield each node to listeners which were attached by validators
-          op_node.typed_children.each do |obj_type, children|
-            children.each do |name, op_child_node|
-              each_node(op_child_node) do |node|
-                for h in handlers
-                  h.call(node)
-                end
-              end
-            end
-          end
-        end
-      end
-
-      # Traverse a node in a rewritten query tree,
-      # visiting the node itself and each of its typed children.
-      def each_node(node)
-        yield(node)
-        node.typed_children.each do |obj_type, children|
-          children.each do |name, node|
-            each_node(node) { |n| yield(n) }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/graphql/internal_representation.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-require "graphql/internal_representation/document"
-require "graphql/internal_representation/node"
-require "graphql/internal_representation/print"
-require "graphql/internal_representation/rewrite"
-require "graphql/internal_representation/scope"
-require "graphql/internal_representation/visit"

data/lib/graphql/language/lexer.rl

@@ -1,258 +0,0 @@
-%%{
-  machine graphql_lexer;
-
-  IDENTIFIER =    [_A-Za-z][_0-9A-Za-z]*;
-  NEWLINE =       [\c\r\n];
-  BLANK   =       [, \t]+;
-  COMMENT =       '#' [^\n\r]*;
-  INT =           '-'? ('0'|[1-9][0-9]*);
-  FLOAT_DECIMAL = '.'[0-9]+;
-  FLOAT_EXP =     ('e' | 'E')?('+' | '-')?[0-9]+;
-  FLOAT =         INT FLOAT_DECIMAL? FLOAT_EXP?;
-  ON =            'on';
-  FRAGMENT =      'fragment';
-  TRUE =          'true';
-  FALSE =         'false';
-  NULL =          'null';
-  QUERY =         'query';
-  MUTATION =      'mutation';
-  SUBSCRIPTION =  'subscription';
-  SCHEMA =        'schema';
-  SCALAR =        'scalar';
-  TYPE =          'type';
-  EXTEND =        'extend';
-  IMPLEMENTS =    'implements';
-  INTERFACE =     'interface';
-  UNION =         'union';
-  ENUM =          'enum';
-  INPUT =         'input';
-  DIRECTIVE =     'directive';
-  LCURLY =        '{';
-  RCURLY =        '}';
-  LPAREN =        '(';
-  RPAREN =        ')';
-  LBRACKET =      '[';
-  RBRACKET =      ']';
-  COLON =         ':';
-  QUOTE =         '"';
-  BACKSLASH = '\\';
-  # Could limit to hex here, but “bad unicode escape” on 0XXF is probably a
-  # more helpful error than “unknown char”
-  UNICODE_ESCAPE = '\\u' [0-9A-Za-z]{4};
-  # https://graphql.github.io/graphql-spec/June2018/#sec-String-Value
-  STRING_ESCAPE = '\\' [\\/bfnrt];
-  BLOCK_QUOTE =   '"""';
-  ESCAPED_BLOCK_QUOTE = '\\"""';
-  BLOCK_STRING_CHAR = (ESCAPED_BLOCK_QUOTE | ^QUOTE | QUOTE{1,2} ^QUOTE);
-  ESCAPED_QUOTE = '\\"';
-  STRING_CHAR =   ((ESCAPED_QUOTE | ^QUOTE) - BACKSLASH) | UNICODE_ESCAPE | STRING_ESCAPE;
-  VAR_SIGN =      '$';
-  DIR_SIGN =      '@';
-  ELLIPSIS =      '...';
-  EQUALS =        '=';
-  BANG =          '!';
-  PIPE =          '|';
-  AMP =           '&';
-
-  QUOTED_STRING = QUOTE STRING_CHAR* QUOTE;
-  BLOCK_STRING = BLOCK_QUOTE BLOCK_STRING_CHAR* QUOTE{0,2} BLOCK_QUOTE;
-  # catch-all for anything else. must be at the bottom for precedence.
-  UNKNOWN_CHAR =         /./;
-
-  # Used with ragel -V for graphviz visualization
-  str := |*
-      QUOTED_STRING => { emit_string(ts, te, meta, block: false) };
-  *|;
-
-  main := |*
-    INT           => { emit(:INT, ts, te, meta) };
-    FLOAT         => { emit(:FLOAT, ts, te, meta) };
-    ON            => { emit(:ON, ts, te, meta, "on") };
-    FRAGMENT      => { emit(:FRAGMENT, ts, te, meta, "fragment") };
-    TRUE          => { emit(:TRUE, ts, te, meta, "true") };
-    FALSE         => { emit(:FALSE, ts, te, meta, "false") };
-    NULL          => { emit(:NULL, ts, te, meta, "null") };
-    QUERY         => { emit(:QUERY, ts, te, meta, "query") };
-    MUTATION      => { emit(:MUTATION, ts, te, meta, "mutation") };
-    SUBSCRIPTION  => { emit(:SUBSCRIPTION, ts, te, meta, "subscription") };
-    SCHEMA        => { emit(:SCHEMA, ts, te, meta) };
-    SCALAR        => { emit(:SCALAR, ts, te, meta) };
-    TYPE          => { emit(:TYPE, ts, te, meta) };
-    EXTEND        => { emit(:EXTEND, ts, te, meta) };
-    IMPLEMENTS    => { emit(:IMPLEMENTS, ts, te, meta) };
-    INTERFACE     => { emit(:INTERFACE, ts, te, meta) };
-    UNION         => { emit(:UNION, ts, te, meta) };
-    ENUM          => { emit(:ENUM, ts, te, meta) };
-    INPUT         => { emit(:INPUT, ts, te, meta) };
-    DIRECTIVE     => { emit(:DIRECTIVE, ts, te, meta) };
-    RCURLY        => { emit(:RCURLY, ts, te, meta, "}") };
-    LCURLY        => { emit(:LCURLY, ts, te, meta, "{") };
-    RPAREN        => { emit(:RPAREN, ts, te, meta, ")") };
-    LPAREN        => { emit(:LPAREN, ts, te, meta, "(")};
-    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) };
-    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) };
-
-    NEWLINE => {
-      meta[:line] += 1
-      meta[:col] = 1
-    };
-
-    BLANK   => { meta[:col] += te - ts };
-
-    UNKNOWN_CHAR => { emit(:UNKNOWN_CHAR, ts, te, meta) };
-
-  *|;
-}%%
-
-# frozen_string_literal: true
-
-module GraphQL
-  module Language
-    module Lexer
-      def self.tokenize(query_string)
-        run_lexer(query_string)
-      end
-
-      # Replace any escaped unicode or whitespace with the _actual_ characters
-      # To avoid allocating more strings, this modifies the string passed into it
-      def self.replace_escaped_characters_in_place(raw_string)
-        raw_string.gsub!(ESCAPES, ESCAPES_REPLACE)
-        raw_string.gsub!(UTF_8, &UTF_8_REPLACE)
-        nil
-      end
-
-      private
-
-      %% write data;
-
-      def self.run_lexer(query_string)
-        data = query_string.unpack("c*")
-        eof = data.length
-
-        # Since `Lexer` is a module, store all lexer state
-        # in this local variable:
-        meta = {
-          line: 1,
-          col: 1,
-          data: data,
-          tokens: [],
-          previous_token: nil,
-        }
-
-        p ||= 0
-        pe ||= data.length
-
-        %% write init;
-
-        %% write exec;
-
-        meta[:tokens]
-      end
-
-      def self.record_comment(ts, te, meta)
-        token = GraphQL::Language::Token.new(
-          :COMMENT,
-          meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING),
-          meta[:line],
-          meta[:col],
-          meta[:previous_token],
-        )
-
-        meta[:previous_token] = token
-
-        meta[:col] += te - ts
-      end
-
-      def self.emit(token_name, ts, te, meta, token_value = nil)
-        token_value ||= meta[:data][ts, te - ts].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING)
-        meta[:tokens] << token = GraphQL::Language::Token.new(
-          token_name,
-          token_value,
-          meta[:line],
-          meta[:col],
-          meta[:previous_token],
-        )
-        meta[:previous_token] = token
-        # Bump the column counter for the next token
-        meta[:col] += te - ts
-      end
-
-      ESCAPES = /\\["\\\/bfnrt]/
-      ESCAPES_REPLACE = {
-        '\\"' => '"',
-        "\\\\" => "\\",
-        "\\/" => '/',
-        "\\b" => "\b",
-        "\\f" => "\f",
-        "\\n" => "\n",
-        "\\r" => "\r",
-        "\\t" => "\t",
-      }
-
-      UTF_8 = /\\u[\dAa-f]{4}/i
-      UTF_8_REPLACE = ->(m) { [m[-4..-1].to_i(16)].pack('U'.freeze) }
-
-      VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{UTF_8})*\z/o
-
-      PACK_DIRECTIVE = "c*"
-      UTF_8_ENCODING = "UTF-8"
-
-      def self.emit_string(ts, te, meta, block:)
-        quotes_length = block ? 3 : 1
-        value = meta[:data][ts + quotes_length, te - ts - 2 * quotes_length].pack(PACK_DIRECTIVE).force_encoding(UTF_8_ENCODING) || ''
-        line_incr = 0
-        if block && !value.length.zero?
-          line_incr = value.count("\n")
-          value = GraphQL::Language::BlockString.trim_whitespace(value)
-        end
-        # TODO: replace with `String#match?` when we support only Ruby 2.4+
-        # (It's faster: https://bugs.ruby-lang.org/issues/8110)
-        if !value.valid_encoding? || value !~ VALID_STRING
-          meta[:tokens] << token = GraphQL::Language::Token.new(
-            :BAD_UNICODE_ESCAPE,
-            value,
-            meta[:line],
-            meta[:col],
-            meta[:previous_token],
-          )
-        else
-          replace_escaped_characters_in_place(value)
-
-          if !value.valid_encoding?
-            meta[:tokens] << token = GraphQL::Language::Token.new(
-              :BAD_UNICODE_ESCAPE,
-              value,
-              meta[:line],
-              meta[:col],
-              meta[:previous_token],
-            )
-          else
-            meta[:tokens] << token = GraphQL::Language::Token.new(
-              :STRING,
-              value,
-              meta[:line],
-              meta[:col],
-              meta[:previous_token],
-            )
-          end
-        end
-
-        meta[:previous_token] = token
-        meta[:col] += te - ts
-        meta[:line] += line_incr
-      end
-    end
-  end
-end

data/lib/graphql/list_type.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # A list type modifies another type.
-  #
-  # List types can be created with the type helper (`types[InnerType]`)
-  # or {BaseType#to_list_type} (`InnerType.to_list_type`)
-  #
-  # For return types, it says that the returned value will be a list of the modified.
-  #
-  # @example A field which returns a list of items
-  #   field :items, types[ItemType]
-  #   # or
-  #   field :items, ItemType.to_list_type
-  #
-  # For input types, it says that the incoming value will be a list of the modified type.
-  #
-  # @example A field which accepts a list of strings
-  #   field :newNames do
-  #     # ...
-  #     argument :values, types[types.String]
-  #     # or
-  #     argument :values, types.String.to_list_type
-  #   end
-  #
-  # Given a list type, you can always get the underlying type with {#unwrap}.
-  #
-  class ListType < GraphQL::BaseType
-    include GraphQL::BaseType::ModifiesAnotherType
-    attr_reader :of_type
-    def initialize(of_type:)
-      super()
-      @of_type = of_type
-    end
-
-    def kind
-      GraphQL::TypeKinds::LIST
-    end
-
-    def to_s
-      "[#{of_type.to_s}]"
-    end
-    alias_method :inspect, :to_s
-    alias :to_type_signature :to_s
-
-    def coerce_result(value, ctx = nil)
-      if ctx.nil?
-        warn_deprecated_coerce("coerce_isolated_result")
-        ctx = GraphQL::Query::NullContext
-      end
-      ensure_array(value).map { |item| item.nil? ? nil : of_type.coerce_result(item, ctx) }
-    end
-
-    def list?
-      true
-    end
-
-    private
-
-    def coerce_non_null_input(value, ctx)
-      ensure_array(value).map { |item| of_type.coerce_input(item, ctx) }
-    end
-
-    def validate_non_null_input(value, ctx)
-      result = GraphQL::Query::InputValidationResult.new
-
-      ensure_array(value).each_with_index do |item, index|
-        item_result = of_type.validate_input(item, ctx)
-        if !item_result.valid?
-          result.merge_result!(index, item_result)
-        end
-      end
-
-      result
-    end
-
-    def ensure_array(value)
-      value.is_a?(Array) ? value : [value]
-    end
-  end
-end

data/lib/graphql/literal_validation_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class LiteralValidationError < GraphQL::Error
-    attr_accessor :ast_value
-  end
-end