graphql 0.12.1 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6682396f1618ee3660ec3120bf597c109d0e2752
-  data.tar.gz: 93a3813ff37f3eb9f4e447eda9aabd3db2688de3
+  metadata.gz: e39609ec3ac4ee1756f3dcbd618785468f05d895
+  data.tar.gz: 96aac564a69c22795a299ea4430b1bb95542a788
 SHA512:
-  metadata.gz: 09eb390035a47146f403a393c1695d7d6355a7d7573c70a277547113f2abad887cded1bb275fa7865c57df5631119487fdd3e50ddf859e705960fc0f67c8fe6e
-  data.tar.gz: d4bef1a775db4a7bd2d58a60c283bce67942ab41bfb551d3d1a7f8080ecdcfc2959d7c0f51872cb80016e77cca68bd04fbede2479217c4b994e6919fb68f86e8
+  metadata.gz: 4ad5ecccde050131fe70cb6a33d6fdc1acb574a8e13e63af82da209313388f53fc042627f0ca32c00999e35fb227b0e1fd7068f69d7209ed5c2b20beb45a19cf
+  data.tar.gz: 8cecd7002d9067f04e5ac6a7381aab405d6e2acd9df5baf45976b994e49615e1fe9d94585df62e9728c7d8c8788ac7b408a40273308221f56e11af315816d74c

data/lib/graphql.rb

@@ -1,5 +1,4 @@
 require "json"
-require "parslet"
 require "set"
 require "singleton"
 require "forwardable"
@@ -22,57 +21,48 @@ module GraphQL
   # @param [String] a GraphQL query string
   # @return [GraphQL::Language::Nodes::Document]
   def self.parse(query_string)
-    parse_with_parslet(query_string)
+    parse_with_racc(query_string)
   end
 
-  def self.parse_with_parslet(string)
-    tree = GraphQL::PARSER.parse(string)
-    document = GraphQL::TRANSFORM.apply(tree)
-    if !document.is_a?(GraphQL::Language::Nodes::Document)
-      raise("Parse failed! Sorry, somehow we failed to turn this string into a document. Please report this bug!")
-    end
-    document
-  rescue Parslet::ParseFailed => error
-    line, col = error.cause.source.line_and_column(error.cause.pos)
-    raise GraphQL::ParseError.new(error.message, line, col, string)
+  def self.parse_with_racc(string)
+    GraphQL::Language::Parser.parse(string)
   end
 end
 
 # Order matters for these:
 
-require 'graphql/define'
-require 'graphql/base_type'
-require 'graphql/object_type'
+require "graphql/define"
+require "graphql/base_type"
+require "graphql/object_type"
 
-require 'graphql/enum_type'
-require 'graphql/input_object_type'
-require 'graphql/interface_type'
-require 'graphql/list_type'
-require 'graphql/non_null_type'
-require 'graphql/union_type'
+require "graphql/enum_type"
+require "graphql/input_object_type"
+require "graphql/interface_type"
+require "graphql/list_type"
+require "graphql/non_null_type"
+require "graphql/union_type"
 
-require 'graphql/argument'
-require 'graphql/field'
-require 'graphql/type_kinds'
+require "graphql/argument"
+require "graphql/field"
+require "graphql/type_kinds"
 
-require 'graphql/scalar_type'
-require 'graphql/boolean_type'
-require 'graphql/float_type'
-require 'graphql/id_type'
-require 'graphql/int_type'
-require 'graphql/string_type'
+require "graphql/scalar_type"
+require "graphql/boolean_type"
+require "graphql/float_type"
+require "graphql/id_type"
+require "graphql/int_type"
+require "graphql/string_type"
+require "graphql/directive"
 
-require 'graphql/introspection'
-require 'graphql/language'
-require 'graphql/directive'
-require 'graphql/schema'
-require 'graphql/schema/printer'
+require "graphql/introspection"
+require "graphql/language"
+require "graphql/schema"
+require "graphql/schema/printer"
 
 # Order does not matter for these:
 
-require 'graphql/execution_error'
-require 'graphql/invalid_null_error'
-require 'graphql/query'
-require 'graphql/repl'
-require 'graphql/static_validation'
-require 'graphql/version'
+require "graphql/execution_error"
+require "graphql/invalid_null_error"
+require "graphql/query"
+require "graphql/static_validation"
+require "graphql/version"

data/lib/graphql/argument.rb

@@ -1,23 +1,25 @@
-# Used for defined arguments ({Field}, {InputObjectType})
-#
-# {#name} must be a String.
-#
-# @example defining an argument for a field
-#   GraphQL::Field.define do
-#     # ...
-#     argument :favoriteFood, types.String, "Favorite thing to eat", default_value: "pizza"
-#   end
-#
-# @example defining an input field for an {InputObjectType}
-#   GraphQL::InputObjectType.define do
-#     input_field :newName, !types.String
-#   end
-#
-class GraphQL::Argument
-  include GraphQL::Define::InstanceDefinable
-  accepts_definitions :name, :type, :description, :default_value
-  attr_accessor :type, :description, :default_value
+module GraphQL
+  # Used for defined arguments ({Field}, {InputObjectType})
+  #
+  # {#name} must be a String.
+  #
+  # @example defining an argument for a field
+  #   GraphQL::Field.define do
+  #     # ...
+  #     argument :favoriteFood, types.String, "Favorite thing to eat", default_value: "pizza"
+  #   end
+  #
+  # @example defining an input field for an {InputObjectType}
+  #   GraphQL::InputObjectType.define do
+  #     input_field :newName, !types.String
+  #   end
+  #
+  class Argument
+    include GraphQL::Define::InstanceDefinable
+    accepts_definitions :name, :type, :description, :default_value
+    attr_accessor :type, :description, :default_value
 
-  # @return [String] The name of this argument on its {GraphQL::Field} or {GraphQL::InputObjectType}
-  attr_accessor :name
+    # @return [String] The name of this argument on its {GraphQL::Field} or {GraphQL::InputObjectType}
+    attr_accessor :name
+  end
 end

data/lib/graphql/base_type.rb

@@ -50,25 +50,22 @@ module GraphQL
       # Maybe you'll need to override this in your own interfaces!
       #
       # @param object [Object] the object which needs a type to expose it
+      # @param ctx [GraphQL::Query::Context]
       # @return [GraphQL::ObjectType] the type which should expose `object`
-      def resolve_type(object)
-        instance_exec(object, &(@resolve_type_proc || DEFAULT_RESOLVE_TYPE))
+      def resolve_type(object, ctx)
+        instance_exec(object, ctx, &(@resolve_type_proc || DEFAULT_RESOLVE_TYPE))
       end
 
       # The default implementation of {#resolve_type} gets `object.class.name`
       # and finds a type with the same name
-      DEFAULT_RESOLVE_TYPE = -> (object) {
+      DEFAULT_RESOLVE_TYPE = -> (object, ctx) {
         type_name = object.class.name
-        possible_types.find {|t| t.name == type_name}
+        ctx.schema.possible_types(self).find {|t| t.name == type_name}
       }
 
       def resolve_type=(new_proc)
         @resolve_type_proc = new_proc || DEFAULT_RESOLVE_TYPE
       end
-
-      def include?(type)
-        possible_types.include?(type)
-      end
     end
 
     # Print the human-readable name of this type using the query-string naming pattern

data/lib/graphql/define/assign_argument.rb

@@ -10,8 +10,11 @@ module GraphQL
         end
         argument.name = name.to_s
         argument.type = type
-        argument.description = description
-        argument.default_value = default_value
+
+        description && argument.description = description
+        # check nil because false is a valid value
+        default_value != nil && argument.default_value = default_value
+
         target.arguments[name.to_s] = argument
       end
     end

data/lib/graphql/define/type_definer.rb

@@ -5,12 +5,13 @@ module GraphQL
     # Passed into initialization blocks, eg {ObjectType#initialize}, {Field#initialize}
     class TypeDefiner
       include Singleton
-
+      # rubocop:disable Style/MethodName
       def Int;      GraphQL::INT_TYPE;      end
       def String;   GraphQL::STRING_TYPE;   end
       def Float;    GraphQL::FLOAT_TYPE;    end
       def Boolean;  GraphQL::BOOLEAN_TYPE;  end
       def ID;       GraphQL::ID_TYPE;       end
+      # rubocop:enable Style/MethodName
 
       # Make a {ListType} which wraps the input type
       #

data/lib/graphql/directive.rb

@@ -1,39 +1,37 @@
-# This implementation of `Directive` is ... not robust.
-# It seems like this area of the spec is still getting worked out, so
-# {Directive} & {DirectiveChain} implement `@skip` and `@include` with
-# minimal impact on query execution.
-class GraphQL::Directive
-  include GraphQL::Define::InstanceDefinable
-  accepts_definitions :on, :name, :description, :resolve, argument: GraphQL::Define::AssignArgument
-
-  attr_accessor :on, :arguments, :name, :description
-
-  LOCATIONS = [
-    ON_OPERATION =  :on_operation?,
-    ON_FRAGMENT =   :on_fragment?,
-    ON_FIELD =      :on_field?,
-  ]
-
-  LOCATIONS.each do |location|
-    define_method(location) { self.on.include?(location) }
-  end
-
-  def initialize
-    @arguments = {}
-  end
-
-  def resolve(arguments, proc)
-    @resolve_proc.call(arguments, proc)
-  end
-
-  def resolve=(resolve_proc)
-    @resolve_proc = resolve_proc
-  end
-
-  def to_s
-    "<GraphQL::Directive #{name}>"
+module GraphQL
+  class Directive
+    include GraphQL::Define::InstanceDefinable
+    accepts_definitions :locations, :name, :description, :include_proc, argument: GraphQL::Define::AssignArgument
+
+    attr_accessor :locations, :arguments, :name, :description
+
+    LOCATIONS = [
+      QUERY =               :QUERY,
+      MUTATION =            :MUTATION,
+      SUBSCRIPTION =        :SUBSCRIPTION,
+      FIELD =               :FIELD,
+      FRAGMENT_DEFINITION = :FRAGMENT_DEFINITION,
+      FRAGMENT_SPREAD =     :FRAGMENT_SPREAD,
+      INLINE_FRAGMENT =     :INLINE_FRAGMENT,
+    ]
+
+    def initialize
+      @arguments = {}
+    end
+
+    def include?(arguments)
+      @include_proc.call(arguments)
+    end
+
+    def include_proc=(include_proc)
+      @include_proc = include_proc
+    end
+
+    def to_s
+      "<GraphQL::Directive #{name}>"
+    end
   end
 end
 
-require 'graphql/directive/include_directive'
-require 'graphql/directive/skip_directive'
+require "graphql/directive/include_directive"
+require "graphql/directive/skip_directive"

data/lib/graphql/directive/include_directive.rb

@@ -1,14 +1,10 @@
 GraphQL::Directive::IncludeDirective = GraphQL::Directive.define do
   name "include"
   description "Include this part of the query if `if` is true"
-  on([GraphQL::Directive::ON_FIELD, GraphQL::Directive::ON_FRAGMENT])
+  locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
   argument :if, !GraphQL::BOOLEAN_TYPE
 
-  resolve -> (arguments, proc) {
-    if arguments["if"]
-      proc.call
-    else
-      nil
-    end
+  include_proc -> (arguments) {
+    arguments["if"]
   }
 end

data/lib/graphql/directive/skip_directive.rb

@@ -1,15 +1,11 @@
 GraphQL::Directive::SkipDirective = GraphQL::Directive.define do
   name "skip"
   description "Ignore this part of the query if `if` is true"
-  on([GraphQL::Directive::ON_FIELD, GraphQL::Directive::ON_FRAGMENT])
+  locations([GraphQL::Directive::FIELD, GraphQL::Directive::FRAGMENT_SPREAD, GraphQL::Directive::INLINE_FRAGMENT])
 
   argument :if, !GraphQL::BOOLEAN_TYPE
 
-  resolve -> (arguments, proc) {
-    if !arguments["if"]
-      proc.call
-    else
-      nil
-    end
+  include_proc -> (arguments) {
+    !arguments["if"]
   }
 end

data/lib/graphql/enum_type.rb

@@ -1,92 +1,94 @@
-# A finite set of possible values, represented in query strings with
-# SCREAMING_CASE_NAMES
-#
-# @example An enum of programming languages
-#
-#   LanguageEnum = GraphQL::EnumType.define do
-#     name "Languages"
-#     description "Programming languages for Web projects"
-#     value("PYTHON", "A dynamic, function-oriented language")
-#     value("RUBY", "A very dynamic language aimed at programmer happiness")
-#     value("JAVASCRIPT", "Accidental lingua franca of the web")
-#   end
-class GraphQL::EnumType < GraphQL::BaseType
-  accepts_definitions value: GraphQL::Define::AssignEnumValue
+module GraphQL
+  # A finite set of possible values, represented in query strings with
+  # SCREAMING_CASE_NAMES
+  #
+  # @example An enum of programming languages
+  #
+  #   LanguageEnum = GraphQL::EnumType.define do
+  #     name "Languages"
+  #     description "Programming languages for Web projects"
+  #     value("PYTHON", "A dynamic, function-oriented language")
+  #     value("RUBY", "A very dynamic language aimed at programmer happiness")
+  #     value("JAVASCRIPT", "Accidental lingua franca of the web")
+  #   end
+  class EnumType < GraphQL::BaseType
+    accepts_definitions value: GraphQL::Define::AssignEnumValue
 
-  def initialize
-    @values_by_name = {}
-    @values_by_value = {}
-  end
+    def initialize
+      @values_by_name = {}
+      @values_by_value = {}
+    end
 
-  def values=(values)
-    @values_by_name = {}
-    @values_by_value = {}
-    values.each { |enum_value| add_value(enum_value) }
-  end
+    def values=(values)
+      @values_by_name = {}
+      @values_by_value = {}
+      values.each { |enum_value| add_value(enum_value) }
+    end
 
-  def add_value(enum_value)
-    @values_by_name[enum_value.name] = enum_value
-    @values_by_value[enum_value.value] = enum_value
-  end
+    def add_value(enum_value)
+      @values_by_name[enum_value.name] = enum_value
+      @values_by_value[enum_value.value] = enum_value
+    end
 
-  def values
-    @values_by_name
-  end
+    def values
+      @values_by_name
+    end
 
-  # Define a value within this enum
-  # @deprecated use {.define} API instead
-  # @param name [String] the string representation of this value
-  # @param description [String]
-  # @param deprecation_reason [String] if provided, `deprecated?` will be true
-  # @param value [Object] the underlying value for this enum value
-  def value(name, description=nil, deprecation_reason: nil, value: name)
-    values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
-  end
+    # Define a value within this enum
+    # @deprecated use {.define} API instead
+    # @param name [String] the string representation of this value
+    # @param description [String]
+    # @param deprecation_reason [String] if provided, `deprecated?` will be true
+    # @param value [Object] the underlying value for this enum value
+    def value(name, description=nil, deprecation_reason: nil, value: name)
+      values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
+    end
 
-  def kind
-    GraphQL::TypeKinds::ENUM
-  end
+    def kind
+      GraphQL::TypeKinds::ENUM
+    end
 
-  def validate_non_null_input(value_name)
-    result = GraphQL::Query::InputValidationResult.new
+    def validate_non_null_input(value_name)
+      result = GraphQL::Query::InputValidationResult.new
 
-    if !@values_by_name.key?(value_name)
-      result.add_problem("Expected #{JSON.dump(value_name)} to be one of: #{@values_by_name.keys.join(', ')}")
-    end
+      if !@values_by_name.key?(value_name)
+        result.add_problem("Expected #{JSON.dump(value_name)} to be one of: #{@values_by_name.keys.join(', ')}")
+      end
 
-    result
-  end
+      result
+    end
 
-  # Get the underlying value for this enum value
-  #
-  # @example get episode value from Enum
-  #   episode = EpisodeEnum.coerce("NEWHOPE")
-  #   episode # => 6
-  #
-  # @param value_name [String] the string representation of this enum value
-  # @return [Object] the underlying value for this enum value
-  def coerce_non_null_input(value_name)
-    @values_by_name.fetch(value_name).value
-  end
+    # Get the underlying value for this enum value
+    #
+    # @example get episode value from Enum
+    #   episode = EpisodeEnum.coerce("NEWHOPE")
+    #   episode # => 6
+    #
+    # @param value_name [String] the string representation of this enum value
+    # @return [Object] the underlying value for this enum value
+    def coerce_non_null_input(value_name)
+      @values_by_name.fetch(value_name).value
+    end
 
-  def coerce_result(value)
-    @values_by_value.fetch(value).name
-  end
+    def coerce_result(value)
+      @values_by_value.fetch(value).name
+    end
 
-  def to_s
-    name
-  end
+    def to_s
+      name
+    end
 
-  # A value within an {EnumType}
-  #
-  # Created with {EnumType#value}
-  class EnumValue
-    attr_reader :name, :description, :deprecation_reason, :value
-    def initialize(name:, description:, deprecation_reason:, value:)
-      @name = name
-      @description = description
-      @deprecation_reason = deprecation_reason
-      @value = value
+    # A value within an {EnumType}
+    #
+    # Created with {EnumType#value}
+    class EnumValue
+      attr_reader :name, :description, :deprecation_reason, :value
+      def initialize(name:, description:, deprecation_reason:, value:)
+        @name = name
+        @description = description
+        @deprecation_reason = deprecation_reason
+        @value = value
+      end
     end
   end
 end