graphql 0.12.1 → 0.13.0

data/lib/graphql/language/parser.y

@@ -0,0 +1,264 @@
+class GraphQL::Language::Parser
+rule
+  target: document
+
+  document: definitions_list { return make_node(:Document, definitions: val[0])}
+
+  definitions_list:
+      definition                    { return [val[0]]}
+    | definitions_list definition   { val[0] << val[1] }
+
+  definition:
+      operation_definition
+    | fragment_definition
+
+  operation_definition:
+      name operation_name_opt variable_definitions_opt directives_list_opt selection_set {
+        return  make_node(
+          :OperationDefinition, {
+            operation_type: val[0],
+            name:           val[1],
+            variables:      val[2],
+            directives:     val[3],
+            selections:     val[4],
+            position_source: val[0],
+          }
+        )
+      }
+    | selection_set {
+        return make_node(
+          :OperationDefinition, {
+            operation_type: "query",
+            selections: val[0],
+          }
+        )
+      }
+
+  operation_name_opt:
+      /* none */ { return nil }
+    | name
+
+  variable_definitions_opt:
+      /* none */                              { return [] }
+    | RPAREN variable_definitions_list LPAREN { return val[1] }
+
+  variable_definitions_list:
+      variable_definition                           { return [val[0]] }
+    | variable_definitions_list variable_definition { val[0] << val[1] }
+
+  variable_definition:
+      VAR_SIGN name COLON variable_definition_type_name variable_definition_default_value_opt {
+        return make_node(:VariableDefinition, {
+          name: val[1],
+          type: val[3],
+          default_value: val[4],
+          position_source: val[0],
+        })
+      }
+
+  variable_definition_type_name:
+      name                                            { return make_node(:TypeName, name: val[0])}
+    | variable_definition_type_name BANG              { return make_node(:NonNullType, of_type: val[0]) }
+    | RBRACKET variable_definition_type_name LBRACKET { return make_node(:ListType, of_type: val[1]) }
+
+  variable_definition_default_value_opt:
+      /* none */          { return nil }
+    | EQUALS input_value  { return val[1] }
+
+  selection_set:
+      RCURLY LCURLY                { return [] }
+    | RCURLY selection_list LCURLY { return val[1] }
+
+  selection_set_opt:
+      /* none */    { return [] }
+    | selection_set { return val[0] }
+
+  selection_list:
+      selection                 { return [result] }
+    | selection_list selection  { val[0] << val[1] }
+
+  selection:
+      field
+    | fragment_spread
+    | inline_fragment
+
+  field:
+      name arguments_opt directives_list_opt selection_set_opt {
+            return make_node(
+              :Field, {
+                name:         val[0],
+                arguments:    val[1],
+                directives:   val[2],
+                selections:   val[3],
+                position_source: val[0],
+              }
+            )
+          }
+    | name COLON name arguments_opt directives_list_opt selection_set_opt {
+            return make_node(
+              :Field, {
+                alias:        val[0],
+                name:         val[2],
+                arguments:    val[3],
+                directives:   val[4],
+                selections:   val[5],
+                position_source: val[0],
+              }
+            )
+          }
+
+  name:
+      IDENTIFIER
+    | FRAGMENT
+    | TRUE
+    | FALSE
+    | ON
+
+  arguments_opt:
+      /* none */                    { return [] }
+    | RPAREN LPAREN                 { return [] }
+    | RPAREN arguments_list LPAREN  { return val[1] }
+
+  arguments_list:
+      argument                { return [val[0]] }
+    | arguments_list argument { val[0] << val[1] }
+
+  argument:
+      name COLON input_value { return make_node(:Argument, name: val[0], value: val[2], position_source: val[0])}
+
+  input_value:
+      FLOAT       { return val[0].to_f }
+    | INT         { return val[0].to_i }
+    | STRING      { return val[0].to_s }
+    | TRUE        { return true }
+    | FALSE       { return false }
+    | variable
+    | list_value
+    | object_value
+    | enum_value
+
+  variable: VAR_SIGN name { return make_node(:VariableIdentifier, name: val[1], position_source: val[0]) }
+
+  list_value:
+      RBRACKET LBRACKET                 { return [] }
+    | RBRACKET list_value_list LBRACKET { return val[1] }
+
+  list_value_list:
+      input_value                 { return [val[0]] }
+    | list_value_list input_value { val[0] << val[1] }
+
+  object_value:
+      RCURLY LCURLY                   { return make_node(:InputObject, arguments: [], position_source: val[0])}
+    | RCURLY object_value_list LCURLY { return make_node(:InputObject, arguments: val[1], position_source: val[0])}
+
+  object_value_list:
+      object_value_field                    { return [val[0]] }
+    | object_value_list object_value_field  { val[0] << val[1] }
+
+  object_value_field:
+      name COLON input_value { return make_node(:Argument, name: val[0], value: val[2], position_source: val[0])}
+
+  enum_value: IDENTIFIER { return make_node(:Enum, name: val[0], position_source: val[0])}
+
+  directives_list_opt:
+      /* none */      { return [] }
+    | directives_list
+
+  directives_list:
+      directive                 { return [val[0]] }
+    | directives_list directive { val[0] << val[1] }
+
+  directive: DIR_SIGN name arguments_opt { return make_node(:Directive, name: val[1], arguments: val[2], position_source: val[0]) }
+
+  fragment_spread:
+      ELLIPSIS name directives_list_opt { return make_node(:FragmentSpread, name: val[1], directives: val[2], position_source: val[0]) }
+
+  inline_fragment:
+      ELLIPSIS ON name directives_list_opt selection_set {
+        return make_node(:InlineFragment, {
+          type: val[2],
+          directives: val[3],
+          selections: val[4],
+          position_source: val[0]
+        })
+      }
+    | ELLIPSIS directives_list_opt selection_set {
+        return make_node(:InlineFragment, {
+          type: nil,
+          directives: val[1],
+          selections: val[2],
+          position_source: val[0]
+        })
+      }
+
+  fragment_definition:
+    FRAGMENT name ON name directives_list_opt selection_set {
+      return make_node(:FragmentDefinition, {
+          name:       val[1],
+          type:       val[3],
+          directives: val[4],
+          selections: val[5],
+          position_source: val[0],
+        }
+      )
+    }
+end
+
+---- header ----
+
+
+---- inner ----
+
+def initialize(query_string)
+  @query_string = query_string
+end
+
+def parse_document
+  @document ||= begin
+    @tokens ||= GraphQL::Language::Lexer.tokenize(@query_string)
+    if @tokens.none?
+      make_node(:Document, definitions: [])
+    else
+      do_parse
+    end
+  end
+end
+
+def self.parse(query_string)
+  self.new(query_string).parse_document
+end
+
+private
+
+def next_token
+  lexer_token = @tokens.shift
+  if lexer_token.nil?
+    nil
+  else
+    [lexer_token.name, lexer_token]
+  end
+end
+
+def on_error(parser_token_id, lexer_token, vstack)
+  if lexer_token == "$"
+    raise GraphQL::ParseError.new("Unexpected end of document", nil, nil, @query_string)
+  else
+    parser_token_name = token_to_str(parser_token_id)
+    if parser_token_name.nil?
+      raise GraphQL::ParseError.new("Parse Error on unknown token: {token_id: #{parser_token_id}, lexer_token: #{lexer_token}} from #{@query_string}", nil, nil, @query_string)
+    else
+      line, col = lexer_token.line_and_column
+      raise GraphQL::ParseError.new("Parse error on #{lexer_token.to_s.inspect} (#{parser_token_name}) at [#{line}, #{col}]", line, col, @query_string)
+    end
+  end
+end
+
+def make_node(node_name, assigns)
+  assigns.each do |key, value|
+    if key != :position_source && value.is_a?(GraphQL::Language::Token)
+      assigns[key] = value.to_s
+    end
+  end
+
+  GraphQL::Language::Nodes.const_get(node_name).new(assigns)
+end

data/lib/graphql/language/token.rb

@@ -0,0 +1,21 @@
+module GraphQL
+  module Language
+    class Token
+      attr_reader :name
+      def initialize(value:, name:, line:, col:)
+        @name = name
+        @value = value
+        @line = line
+        @col = col
+      end
+
+      def to_s; @value; end
+      def to_i; @value.to_i; end
+      def to_f; @value.to_f; end
+
+      def line_and_column
+        [@line, @col]
+      end
+    end
+  end
+end

data/lib/graphql/list_type.rb

@@ -1,44 +1,46 @@
-# A list type wraps another type.
-#
-# Get the underlying type with {#unwrap}
-class GraphQL::ListType < GraphQL::BaseType
-  include GraphQL::BaseType::ModifiesAnotherType
-  attr_reader :of_type, :name
-  def initialize(of_type:)
-    @name = "List"
-    @of_type = of_type
-  end
+module GraphQL
+  # A list type wraps another type.
+  #
+  # Get the underlying type with {#unwrap}
+  class ListType < GraphQL::BaseType
+    include GraphQL::BaseType::ModifiesAnotherType
+    attr_reader :of_type, :name
+    def initialize(of_type:)
+      @name = "List"
+      @of_type = of_type
+    end
 
-  def kind
-    GraphQL::TypeKinds::LIST
-  end
+    def kind
+      GraphQL::TypeKinds::LIST
+    end
 
-  def to_s
-    "[#{of_type.to_s}]"
-  end
+    def to_s
+      "[#{of_type.to_s}]"
+    end
 
-  def validate_non_null_input(value)
-    result = GraphQL::Query::InputValidationResult.new
+    def validate_non_null_input(value)
+      result = GraphQL::Query::InputValidationResult.new
 
-    ensure_array(value).each_with_index do |item, index|
-      item_result = of_type.validate_input(item)
-      if !item_result.valid?
-        result.merge_result!(index, item_result)
+      ensure_array(value).each_with_index do |item, index|
+        item_result = of_type.validate_input(item)
+        if !item_result.valid?
+          result.merge_result!(index, item_result)
+        end
       end
-    end
 
-    result
-  end
+      result
+    end
 
 
-  def coerce_non_null_input(value)
-    ensure_array(value).map{ |item| of_type.coerce_input(item) }
-  end
+    def coerce_non_null_input(value)
+      ensure_array(value).map{ |item| of_type.coerce_input(item) }
+    end
 
 
-  private
+    private
 
-  def ensure_array(value)
-    value.is_a?(Array) ? value : [value]
+    def ensure_array(value)
+      value.is_a?(Array) ? value : [value]
+    end
   end
 end

data/lib/graphql/non_null_type.rb

@@ -1,41 +1,43 @@
-# A non-null type wraps another type.
-#
-# Get the underlying type with {#unwrap}
-class GraphQL::NonNullType < GraphQL::BaseType
-  include GraphQL::BaseType::ModifiesAnotherType
+module GraphQL
+  # A non-null type wraps another type.
+  #
+  # Get the underlying type with {#unwrap}
+  class NonNullType < GraphQL::BaseType
+    include GraphQL::BaseType::ModifiesAnotherType
 
-  attr_reader :of_type
-  def initialize(of_type:)
-    @of_type = of_type
-  end
+    attr_reader :of_type
+    def initialize(of_type:)
+      @of_type = of_type
+    end
 
-  def name
-    "Non-Null"
-  end
+    def name
+      "Non-Null"
+    end
 
-  def valid_input?(value)
-    validate_input(value).valid?
-  end
+    def valid_input?(value)
+      validate_input(value).valid?
+    end
 
-  def validate_input(value)
-    if value.nil?
-      result = GraphQL::Query::InputValidationResult.new
-      result.add_problem("Expected value to not be null")
-      result
-    else
-      of_type.validate_input(value)
+    def validate_input(value)
+      if value.nil?
+        result = GraphQL::Query::InputValidationResult.new
+        result.add_problem("Expected value to not be null")
+        result
+      else
+        of_type.validate_input(value)
+      end
     end
-  end
 
-  def coerce_input(value)
-    of_type.coerce_input(value)
-  end
+    def coerce_input(value)
+      of_type.coerce_input(value)
+    end
 
-  def kind
-    GraphQL::TypeKinds::NON_NULL
-  end
+    def kind
+      GraphQL::TypeKinds::NON_NULL
+    end
 
-  def to_s
-    "#{of_type.to_s}!"
+    def to_s
+      "#{of_type.to_s}!"
+    end
   end
 end

data/lib/graphql/object_type.rb

@@ -1,66 +1,63 @@
-# This type exposes fields on an object.
-#
-# @example defining a type for your IMDB clone
-#   MovieType = GraphQL::ObjectType.define do
-#     name "Movie"
-#     description "A full-length film or a short film"
-#     interfaces [ProductionInterface, DurationInterface]
-#
-#     field :runtimeMinutes, !types.Int, property: :runtime_minutes
-#     field :director, PersonType
-#     field :cast, CastType
-#     field :starring, types[PersonType] do
-#       arguments :limit, types.Int
-#       resolve -> (object, args, ctx) {
-#         stars = object.cast.stars
-#         args[:limit] && stars = stars.limit(args[:limit])
-#         stars
-#       }
-#      end
-#   end
-#
-class GraphQL::ObjectType < GraphQL::BaseType
-  accepts_definitions :interfaces, field: GraphQL::Define::AssignObjectField
-  attr_accessor :name, :description, :interfaces
+module GraphQL
+  # This type exposes fields on an object.
+  #
+  # @example defining a type for your IMDB clone
+  #   MovieType = GraphQL::ObjectType.define do
+  #     name "Movie"
+  #     description "A full-length film or a short film"
+  #     interfaces [ProductionInterface, DurationInterface]
+  #
+  #     field :runtimeMinutes, !types.Int, property: :runtime_minutes
+  #     field :director, PersonType
+  #     field :cast, CastType
+  #     field :starring, types[PersonType] do
+  #       arguments :limit, types.Int
+  #       resolve -> (object, args, ctx) {
+  #         stars = object.cast.stars
+  #         args[:limit] && stars = stars.limit(args[:limit])
+  #         stars
+  #       }
+  #      end
+  #   end
+  #
+  class ObjectType < GraphQL::BaseType
+    accepts_definitions :interfaces, field: GraphQL::Define::AssignObjectField
+    attr_accessor :name, :description, :interfaces
 
-  # @return [Hash<String, GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
-  attr_accessor :fields
+    # @return [Hash<String, GraphQL::Field>] Map String fieldnames to their {GraphQL::Field} implementations
+    attr_accessor :fields
 
-  def initialize
-    @fields = {}
-    @interfaces = []
-  end
+    def initialize
+      @fields = {}
+      @interfaces = []
+    end
 
-  # Shovel this type into each interface's `possible_types` array.
-  #
-  # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
-  def interfaces=(new_interfaces)
-    @interfaces ||= []
-    (@interfaces - new_interfaces).each { |i| i.possible_types.delete(self) }
-    (new_interfaces - @interfaces).each { |i| i.possible_types << self }
-    @interfaces = new_interfaces
-  end
+    # @param new_interfaces [Array<GraphQL::Interface>] interfaces that this type implements
+    def interfaces=(new_interfaces)
+      @interfaces = new_interfaces
+    end
 
-  def kind
-    GraphQL::TypeKinds::OBJECT
-  end
+    def kind
+      GraphQL::TypeKinds::OBJECT
+    end
 
-  # @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
+    # @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
 
-  # @return [Array<GraphQL::Field>] All fields, including ones inherited from interfaces
-  def all_fields
-    interface_fields.merge(self.fields).values
-  end
+    # @return [Array<GraphQL::Field>] All fields, including ones inherited from interfaces
+    def all_fields
+      interface_fields.merge(self.fields).values
+    end
 
-  private
+    private
 
-  # Create a {name => defn} hash for fields inherited from interfaces
-  def interface_fields
-    interfaces.reduce({}) do |memo, iface|
-      memo.merge!(iface.fields)
+    # Create a {name => defn} hash for fields inherited from interfaces
+    def interface_fields
+      interfaces.reduce({}) do |memo, iface|
+        memo.merge!(iface.fields)
+      end
     end
   end
 end