graphql 0.11.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd3e3f13402965d47c58fd6a3bc5f4252a208417
-  data.tar.gz: 2b0d0396fdf6fbed1b234cefb21dfb50578b2b49
+  metadata.gz: b779fe5af77f89213fae236cb0e7441bdfe4b0c1
+  data.tar.gz: 457dc5cb4468a2c57f758162dc112db07e0801df
 SHA512:
-  metadata.gz: 221f5b736dbdd2c43cb45b1000b5d843b2a4101d63733a6200b79cc87889c3c0619830bf26e8fba1fa0e980875cb4061246642b2c8cdf45e2f9a6c7bf916d52a
-  data.tar.gz: f67031ea6cb082c2b0906108fb8e772cb4f5464470c0bf0ca449d52b8eb1a21e6e2a8b6040633c99129fc82c7cda8850b30007ea7a137ffb12977b6127e66c37
+  metadata.gz: 1910cea7688e8ddd090ee5e7d64300a6ae39524e2ad5677a0552072ba4704a20213cbd25b9889900bcb2b610b6ff5aedfd9c2757614715aaf44ca4535a091ccd
+  data.tar.gz: cfcbe1c03d9fd8b9ed510af1d64d24dacaf147b337d383eb7de6c596ed200f6a8c2b3c87deef8dfab3cdb7b421811d034a4516c3c6db0e3af089b94758d8cc16

data/lib/graphql.rb

@@ -5,7 +5,10 @@ require "singleton"
 require "forwardable"
 
 module GraphQL
-  class ParseError < StandardError
+  class Error < StandardError
+  end
+
+  class ParseError < Error
     attr_reader :line, :col, :query
     def initialize(message, line, col, query)
       super(message)
@@ -37,7 +40,7 @@ end
 
 # Order matters for these:
 
-require 'graphql/definition_helpers'
+require 'graphql/define'
 require 'graphql/base_type'
 require 'graphql/object_type'
 

data/lib/graphql/argument.rb

@@ -1,5 +1,7 @@
 # Used for defined arguments ({Field}, {InputObjectType})
 #
+# {#name} must be a String.
+#
 # @example defining an argument for a field
 #   GraphQL::Field.define do
 #     # ...
@@ -12,7 +14,10 @@
 #   end
 #
 class GraphQL::Argument
-  include GraphQL::DefinitionHelpers::DefinedByConfig
-  defined_by_config :name, :type, :description, :default_value
-  attr_accessor :name, :type, :description, :default_value
+  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
 end

data/lib/graphql/base_type.rb

@@ -1,8 +1,10 @@
 module GraphQL
   # The parent for all type classes.
   class BaseType
-    include GraphQL::DefinitionHelpers::NonNullWithBang
-    include GraphQL::DefinitionHelpers::DefinedByConfig
+    include GraphQL::Define::NonNullWithBang
+    include GraphQL::Define::InstanceDefinable
+    attr_accessor :name, :description
+    accepts_definitions :name, :description
 
     # @param other [GraphQL::BaseType] compare to this object
     # @return [Boolean] are these types equivalent? (incl. non-null, list)
@@ -50,7 +52,7 @@ module GraphQL
       # @param object [Object] the object which needs a type to expose it
       # @return [GraphQL::ObjectType] the type which should expose `object`
       def resolve_type(object)
-        instance_exec(object, &@resolve_type_proc)
+        instance_exec(object, &(@resolve_type_proc || DEFAULT_RESOLVE_TYPE))
       end
 
       # The default implementation of {#resolve_type} gets `object.class.name`

data/lib/graphql/boolean_type.rb

@@ -1,4 +1,9 @@
 GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
+  # Everything else is nil
+  ALLOWED_INPUTS = [true, false]
+
   name "Boolean"
-  coerce -> (value) { !!value }
+
+  coerce_input -> (value) { ALLOWED_INPUTS.include?(value) ? value : nil }
+  coerce_result -> (value) { !!value }
 end

data/lib/graphql/define.rb

@@ -0,0 +1,8 @@
+require "graphql/define/assign_argument"
+require "graphql/define/assign_enum_value"
+require "graphql/define/assign_object_field"
+require "graphql/define/assignment_dictionary"
+require "graphql/define/defined_object_proxy"
+require "graphql/define/instance_definable"
+require "graphql/define/non_null_with_bang"
+require "graphql/define/type_definer"

data/lib/graphql/define/assign_argument.rb

@@ -0,0 +1,19 @@
+module GraphQL
+  module Define
+    # Turn argument configs into a {GraphQL::Argument}.
+    module AssignArgument
+      def self.call(target, name, type, description = nil, default_value: nil, &block)
+        argument = if block_given?
+          GraphQL::Argument.define(&block)
+        else
+          GraphQL::Argument.new
+        end
+        argument.name = name.to_s
+        argument.type = type
+        argument.description = description
+        argument.default_value = default_value
+        target.arguments[name.to_s] = argument
+      end
+    end
+  end
+end

data/lib/graphql/define/assign_enum_value.rb

@@ -0,0 +1,16 @@
+module GraphQL
+  module Define
+    # Turn enum value configs into a {GraphQL::EnumType::EnumValue} and register it with the {GraphQL::EnumType}
+    module AssignEnumValue
+      def self.call(enum_type, name, desc = nil, deprecation_reason: nil, value: name)
+        enum_value = GraphQL::EnumType::EnumValue.new(
+          name: name,
+          description: desc,
+          deprecation_reason: deprecation_reason,
+          value: value
+        )
+        enum_type.add_value(enum_value)
+      end
+    end
+  end
+end

data/lib/graphql/define/assign_object_field.rb

@@ -0,0 +1,19 @@
+module GraphQL
+  module Define
+    # Turn field configs into a {GraphQL::Field} and attach it to a {GraphQL::ObjectType} or {GraphQL::InterfaceType}
+    module AssignObjectField
+      def self.call(fields_type, name, type = nil, desc = nil, field: nil, property: nil, &block)
+        if block_given?
+          field = GraphQL::Field.define(&block)
+        else
+          field ||= GraphQL::Field.new
+        end
+        type && field.type = type
+        desc && field.description = desc
+        property && field.property = property
+        field.name ||= name.to_s
+        fields_type.fields[name.to_s] = field
+      end
+    end
+  end
+end

data/lib/graphql/define/assignment_dictionary.rb

@@ -0,0 +1,26 @@
+module GraphQL
+  module Define
+    # Create a hash of definitions out of provided arguments.
+    #
+    # @example Create definitions (some default, some custom)
+    #    hash = AssignmentDictionary.create(:name, :description, field: (value, field_name) -> { value.create_field(field) })
+    #
+    module AssignmentDictionary
+      # Turn `keys` into a hash suitable for {GraphQL::Define::InstanceDefinable}
+      # @param Any number of symbols for default assignment, followed by an (optional) hash of custom assignment procs.
+      # @return [Hash] keys are attributes which may be defined. values are procs which assign values to the target object.
+      def self.create(*keys)
+        initial = if keys.last.is_a?(Hash)
+          keys.pop
+        else
+          {}
+        end
+        keys.inject(initial) do |memo, key|
+          assign_key = "#{key}="
+          memo[key] = -> (target, value) { target.public_send(assign_key, value) }
+          memo
+        end
+      end
+    end
+  end
+end

data/lib/graphql/define/defined_object_proxy.rb

@@ -0,0 +1,32 @@
+module GraphQL
+  module Define
+    class DefinedObjectProxy
+      def initialize(target, dictionary)
+        @target = target
+        @dictionary = dictionary
+      end
+
+      def types
+        GraphQL::Define::TypeDefiner.instance
+      end
+
+      def method_missing(name, *args, &block)
+        definition = @dictionary[name]
+        if definition
+          definition.call(@target, *args, &block)
+        else
+          p "Failed to find config #{name} in #{inspect}"
+          super
+        end
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        "<DefinedObjectProxy #{@target} (#{@dictionary.keys})>"
+      end
+    end
+  end
+end

data/lib/graphql/define/instance_definable.rb

@@ -0,0 +1,79 @@
+module GraphQL
+  module Define
+    # This module provides the `.define { ... }` API for {GraphQL::BaseType}, {GraphQL::Field}, {GraphQL::Argument} and {GraphQL::Directive}.
+    #
+    # The goals are:
+    # - Minimal overhead in consuming classes
+    # - Independence between consuming classes
+    # - Extendable by third-party libraries without monkey-patching or other nastiness
+    #
+    # @example Make a class definable
+    #   class Car
+    #     attr_accessor :make, :model, :all_wheel_drive
+    #
+    #     accepts_definitions(
+    #       # These attrs will be defined with plain setters, `{attr}=`
+    #       :make, :model,
+    #       # This attr has a custom definition which applies the config to the target
+    #       doors: -> (car, doors_count) { doors_count.times { car.doors << Door.new } }
+    #     )
+    #   end
+    #
+    #   # Create an instance with `.define`:
+    #   subaru_baja = Car.define do
+    #     make "Subaru"
+    #     model "Baja"
+    #     doors 4
+    #   end
+    #
+    #   # The custom proc was applied:
+    #   subaru_baja.doors #=> [<Door>, <Door>, <Door>, <Door>]
+    #
+    # @example Extending the definition of a class
+    #   # Add some definitions:
+    #   Car.accepts_definitions(:all_wheel_drive)
+    #
+    #   # Use it in a definition
+    #   subaru_baja = Car.define do
+    #     # ...
+    #     all_wheel_drive true
+    #   end
+    #
+    module InstanceDefinable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Define an instance of this class using its {.definitions}.
+        def define(&block)
+          instance = self.new
+          proxy = DefinedObjectProxy.new(instance, dictionary)
+          block && proxy.instance_eval(&block)
+          instance
+        end
+
+        # Attach definitions to this class.
+        # Each symbol in `accepts` will be assigned with `{key}=`.
+        # The last entry in accepts may be a hash of name-proc pairs for custom definitions.
+        def accepts_definitions(*accepts)
+          @own_dictionary = own_dictionary.merge(AssignmentDictionary.create(*accepts))
+        end
+
+        # @return [Hash] combined definitions for self and ancestors
+        def dictionary
+          if superclass.respond_to?(:dictionary)
+            own_dictionary.merge(superclass.dictionary)
+          else
+            own_dictionary
+          end
+        end
+
+        # @return [Hash] definitions for this class only
+        def own_dictionary
+          @own_dictionary ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/graphql/{definition_helpers → define}/non_null_with_bang.rb

@@ -1,5 +1,5 @@
 module GraphQL
-  module DefinitionHelpers
+  module Define
     # Wrap the object in NonNullType in response to `!`
     # @example required Int type
     #   !GraphQL::INT_TYPE

data/lib/graphql/{definition_helpers → define}/type_definer.rb

@@ -1,5 +1,5 @@
 module GraphQL
-  module DefinitionHelpers
+  module Define
     # Some conveniences for definining return & argument types.
     #
     # Passed into initialization blocks, eg {ObjectType#initialize}, {Field#initialize}

data/lib/graphql/directive.rb

@@ -3,9 +3,10 @@
 # {Directive} & {DirectiveChain} implement `@skip` and `@include` with
 # minimal impact on query execution.
 class GraphQL::Directive
-  include GraphQL::DefinitionHelpers::DefinedByConfig
+  include GraphQL::Define::InstanceDefinable
+  accepts_definitions :on, :name, :description, :resolve, argument: GraphQL::Define::AssignArgument
+
   attr_accessor :on, :arguments, :name, :description
-  defined_by_config :on, :arguments, :name, :description, :resolve
 
   LOCATIONS = [
     ON_OPERATION =  :on_operation?,
@@ -17,6 +18,10 @@ class GraphQL::Directive
     define_method(location) { self.on.include?(location) }
   end
 
+  def initialize
+    @arguments = {}
+  end
+
   def resolve(arguments, proc)
     @resolve_proc.call(arguments, proc)
   end

data/lib/graphql/enum_type.rb

@@ -11,16 +11,22 @@
 #     value("JAVASCRIPT", "Accidental lingua franca of the web")
 #   end
 class GraphQL::EnumType < GraphQL::BaseType
-  attr_accessor :name, :description, :values
-  defined_by_config :name, :description, :values
+  accepts_definitions value: GraphQL::Define::AssignEnumValue
+
+  def initialize
+    @values_by_name = {}
+    @values_by_value = {}
+  end
 
   def values=(values)
     @values_by_name = {}
     @values_by_value = {}
-    values.each do |enum_value|
-      @values_by_name[enum_value.name] = enum_value
-      @values_by_value[enum_value.value] = enum_value
-    end
+    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 values

data/lib/graphql/execution_error.rb

@@ -2,7 +2,7 @@ module GraphQL
   # If a field's resolve function returns a {ExecutionError},
   # the error will be inserted into the response's `"errors"` key
   # and the field will resolve to `nil`.
-  class ExecutionError < RuntimeError
+  class ExecutionError < GraphQL::Error
     # @return [GraphQL::Language::Nodes::Field] the field where the error occured
     attr_accessor :ast_node
 

data/lib/graphql/field.rb

@@ -1,6 +1,6 @@
 # {Field}s belong to {ObjectType}s and {InterfaceType}s.
 #
-# They're usually created with the `field` helper.
+# They're usually created with the `field` helper. If you create it by hand, make sure {#name} is a String.
 #
 #
 # @example creating a field
@@ -38,28 +38,23 @@
 #   end
 #
 class GraphQL::Field
-  include GraphQL::DefinitionHelpers::DefinedByConfig
-  attr_accessor :arguments, :deprecation_reason, :name, :description, :type, :property
+  include GraphQL::Define::InstanceDefinable
+  accepts_definitions :name, :description, :resolve, :type, :property, :deprecation_reason, argument: GraphQL::Define::AssignArgument
+
+  attr_accessor :deprecation_reason, :name, :description, :type, :property
   attr_reader :resolve_proc
-  defined_by_config :arguments, :deprecation_reason, :name, :description, :type, :resolve, :property
+
+  # @return [String] The name of this field on its {GraphQL::ObjectType} (or {GraphQL::InterfaceType})
+  attr_reader :name
+
+  # @return [Hash<String, GraphQL::Argument>] Map String argument names to their {GraphQL::Argument} implementations
+  attr_accessor :arguments
 
   def initialize
     @arguments = {}
     @resolve_proc = build_default_resolver
   end
 
-  def arguments(new_arguments=nil)
-    if !new_arguments.nil?
-      self.arguments=(new_arguments)
-    end
-    @arguments
-  end
-
-  # Define the arguments for this field using {StringNamedHash}
-  def arguments=(new_arguments)
-    @arguments = GraphQL::DefinitionHelpers::StringNamedHash.new(new_arguments).to_h
-  end
-
   # Get a value for this field
   # @example resolving a field value
   #   field.resolve(obj, args, ctx)
@@ -89,6 +84,18 @@ class GraphQL::Field
     end
   end
 
+  # You can only set a field's name _once_ -- this to prevent
+  # passing the same {Field} to multiple `.field` calls.
+  #
+  # This is important because {#name} may be used by {#resolve}.
+  def name=(new_name)
+    if @name.nil?
+      @name = new_name
+    else
+      raise("Can't rename an already-named field. (Tried to rename \"#{@name}\" to \"#{new_name}\".) If you're passing a field with the `field:` argument, make sure it's an unused instance of GraphQL::Field.")
+    end
+  end
+
   def to_s
     "<Field: #{name || "not-named"}>"
   end
@@ -96,13 +103,9 @@ class GraphQL::Field
   private
 
   def build_default_resolver
-    # Note: lambda accesses the current Field via self
-    -> (t, a, c) do
-      if property = self.property
-        t.public_send(property)
-      else
-        GraphQL::Query::DEFAULT_RESOLVE
-      end
+    -> (obj, args, ctx) do
+      resolve_method = self.property || self.name
+      obj.public_send(resolve_method)
     end
   end
 end