graphql 1.13.12 → 2.0.21

data/lib/graphql/language/lexer.rl

@@ -1,260 +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';
-  REPEATABLE =    'repeatable';
-  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) };
-    REPEATABLE    => { emit(:REPEATABLE, ts, te, meta, "repeatable") };
-    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(PACK_DIRECTIVE)
-        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.empty?
-          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.match?(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/non_null_type.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # A non-null type modifies another type.
-  #
-  # Non-null types can be created with `!` (`InnerType!`)
-  # or {BaseType#to_non_null_type} (`InnerType.to_non_null_type`)
-  #
-  # For return types, it says that the returned value will _always_ be present.
-  #
-  # @example A field which _always_ returns an error
-  #   field :items, !ItemType
-  #   # or
-  #   field :items, ItemType.to_non_null_type
-  #
-  # (If the application fails to return a value, {InvalidNullError} will be passed to {Schema#type_error}.)
-  #
-  # For input types, it says that the incoming value _must_ be provided by the query.
-  #
-  # @example A field which _requires_ a string input
-  #   field :newNames do
-  #     # ...
-  #     argument :values, !types.String
-  #     # or
-  #     argument :values, types.String.to_non_null_type
-  #   end
-  #
-  # (If a value isn't provided, {Query::VariableValidationError} will be raised).
-  #
-  # Given a non-null type, you can always get the underlying type with {#unwrap}.
-  #
-  class NonNullType < GraphQL::BaseType
-    include GraphQL::BaseType::ModifiesAnotherType
-    extend Forwardable
-
-    attr_reader :of_type
-    def initialize(of_type:)
-      super()
-      @of_type = of_type
-    end
-
-    def valid_input?(value, ctx)
-      validate_input(value, ctx).valid?
-    end
-
-    def validate_input(value, ctx)
-      if value.nil?
-        result = GraphQL::Query::InputValidationResult.new
-        result.add_problem("Expected value to not be null")
-        result
-      else
-        of_type.validate_input(value, ctx)
-      end
-    end
-
-    def_delegators :@of_type, :coerce_input, :coerce_result, :list?
-
-    def kind
-      GraphQL::TypeKinds::NON_NULL
-    end
-
-    def to_s
-      "#{of_type.to_s}!"
-    end
-    alias_method :inspect, :to_s
-    alias :to_type_signature :to_s
-
-    def non_null?
-      true
-    end
-  end
-end

data/lib/graphql/object_type.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  # @api deprecated
-  class ObjectType < GraphQL::BaseType
-    extend Define::InstanceDefinable::DeprecatedDefine
-
-    deprecated_accepts_definitions :interfaces, :fields, :mutation, :relay_node_type, field: GraphQL::Define::AssignObjectField
-    deprecated_accepts_definitions implements: ->(type, *interfaces, inherit: false) { type.implements(interfaces, inherit: inherit) }
-
-    attr_accessor :fields, :mutation, :relay_node_type
-    ensure_defined(:fields, :mutation, :interfaces, :relay_node_type)
-
-    # @!attribute fields
-    #   @return [Hash<String => GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
-
-    # @!attribute mutation
-    #   @return [GraphQL::Relay::Mutation, nil] The mutation this object type was derived from, if it is an auto-generated payload type.
-
-    def initialize
-      super
-      @fields = {}
-      @clean_inherited_fields = nil
-      @structural_interface_type_memberships = []
-      @inherited_interface_type_memberships = []
-    end
-
-    def initialize_copy(other)
-      super
-      @structural_interface_type_memberships = other.structural_interface_type_memberships.dup
-      @inherited_interface_type_memberships = other.inherited_interface_type_memberships.dup
-      @fields = other.fields.dup
-    end
-
-    # This method declares interfaces for this type AND inherits any field definitions
-    # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
-    # @deprecated Use `implements` instead of `interfaces`.
-    def interfaces=(new_interfaces)
-      @structural_interface_type_memberships = []
-      @inherited_interface_type_memberships = []
-      @clean_inherited_fields = nil
-      implements(new_interfaces, inherit: true)
-    end
-
-    def interfaces(ctx = GraphQL::Query::NullContext)
-      ensure_defined
-      visible_ifaces = []
-      unfiltered = ctx == GraphQL::Query::NullContext
-      [@structural_interface_type_memberships, @inherited_interface_type_memberships].each do |tms|
-        tms.each do |type_membership|
-          if unfiltered || type_membership.visible?(ctx)
-            # if this is derived from a class-based object, we have to
-            # get the `.graphql_definition` of the attached interface.
-            visible_ifaces << GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
-          end
-        end
-      end
-
-      visible_ifaces
-    end
-
-    def kind
-      GraphQL::TypeKinds::OBJECT
-    end
-
-    # This fields doesnt have instrumenation applied
-    # @see [Schema#get_field] Get field with instrumentation
-    # @return [GraphQL::Field] The field definition for `field_name` (may be inherited from interfaces)
-    def get_field(field_name)
-      fields[field_name] || interface_fields[field_name]
-    end
-
-    # These fields don't have instrumenation applied
-    # @see [Schema#get_fields] Get fields with instrumentation
-    # @return [Array<GraphQL::Field>] All fields, including ones inherited from interfaces
-    def all_fields
-      interface_fields.merge(self.fields).values
-    end
-
-    # Declare that this object implements this interface.
-    # This declaration will be validated when the schema is defined.
-    # @param interfaces [Array<GraphQL::Interface>] add a new interface that this type implements
-    # @param inherits [Boolean] If true, copy the interfaces' field definitions to this type
-    def implements(interfaces, inherit: false, **options)
-      if !interfaces.is_a?(Array)
-        raise ArgumentError, "`implements(interfaces)` must be an array, not #{interfaces.class} (#{interfaces})"
-      end
-      @clean_inherited_fields = nil
-
-      type_memberships = inherit ? @inherited_interface_type_memberships : @structural_interface_type_memberships
-      interfaces.each do |iface|
-        iface = BaseType.resolve_related_type(iface)
-        if iface.is_a?(GraphQL::InterfaceType)
-          type_memberships << iface.type_membership_class.new(iface, self, **options)
-        end
-      end
-    end
-
-    def resolve_type_proc
-      nil
-    end
-
-    attr_writer :structural_interface_type_memberships
-
-    protected
-
-    attr_reader :structural_interface_type_memberships, :inherited_interface_type_memberships
-
-    private
-
-    def normalize_interfaces(ifaces)
-      ifaces.map { |i_type| GraphQL::BaseType.resolve_related_type(i_type) }
-    end
-
-    def interface_fields
-      if @clean_inherited_fields
-        @clean_inherited_fields
-      else
-        ensure_defined
-        @clean_inherited_fields = {}
-        @inherited_interface_type_memberships.each do |type_membership|
-          iface = GraphQL::BaseType.resolve_related_type(type_membership.abstract_type)
-          if iface.is_a?(GraphQL::InterfaceType)
-            @clean_inherited_fields.merge!(iface.fields)
-          end
-        end
-        @clean_inherited_fields
-      end
-    end
-  end
-end