graphql 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a35f790dd696036b5c7ea909517a2108891d2732
-  data.tar.gz: 795e06d90a94be917cf6ffaf911d00e5c14faade
+  metadata.gz: 9a73d6da0ba5269a9b68a0bdd479058ac4b65783
+  data.tar.gz: fb49181fff74d8a45fa7ac2d6ef941ce9a20eedd
 SHA512:
-  metadata.gz: e62e25e0fedcbb6509d55d8f539f766d82429bafa3d278dde5fa3ca45420bc2a6cbbc3262b465a6f936ec76fcbb8296f4c7977cb8fdfd4581b818503570be372
-  data.tar.gz: e863e0d3699bb9233f96da31af72e42422cc18c0f1765f2446851f65e76c67a7c16bcd1862b863e048aced999fca335c0a7d1c6dfbbefb3a0981499c74bfa84a
+  metadata.gz: 7fc070deec02d1ad30a5f6807692010920a0ee69395205a1cf11f1dd98ec3ebb1ea55ca228c60e5165d03644cdf38a8a1649c9025e00d46cdb72e715acd2e586
+  data.tar.gz: b22f2cbe6338c2d30f1a6b1ca6d772d49d6ba396370f519b473105c61ae512e5605e891ca1f53936f8f41d08d49e4e8d1615f759cc34ebb646a22ad20cc0d755

data/lib/graph_ql/argument.rb

@@ -1,10 +1,44 @@
 # Used for defined arguments ({Field}, {InputObjectType})
 #
-# Created by {ArgumentDefiner}
+# @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
-  attr_reader :type, :description, :default_value
-  attr_accessor :name
-  def initialize(type:, description: nil, default_value: nil, name: nil)
+  attr_accessor :name, :type, :description, :default_value
+
+  include GraphQL::DefinitionHelpers::DefinedByConfig
+
+  # This object is `self` when you're defining arguments with a block.
+  # @example `argument` helper's `self` is a DefinitionConfig
+  #
+  #   argument :name do
+  #     puts self.class.name
+  #   end
+  #   # => GraphQL::Argument::DefinitionConfig
+  #
+  class DefinitionConfig
+    extend GraphQL::DefinitionHelpers::Definable
+    attr_definable :type, :description, :default_value, :name
+
+    def to_instance
+      GraphQL::Argument.new(
+        type: type,
+        description: description,
+        default_value: default_value,
+        name: name,
+      )
+    end
+  end
+
+  def initialize(type: nil, description: nil, default_value: nil, name: nil)
     @type = type
     @description = description,
     @default_value = default_value

data/lib/graph_ql/boolean_type.rb

@@ -1,6 +1,4 @@
-GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.new do |t|
-  t.name "Boolean"
-  def t.coerce(value)
-    !!value
-  end
+GraphQL::BOOLEAN_TYPE = GraphQL::ScalarType.define do
+  name "Boolean"
+  coerce -> (value) { !!value }
 end

data/lib/graph_ql/definition_helpers.rb

@@ -6,5 +6,6 @@ require 'graph_ql/definition_helpers/argument_definer'
 require 'graph_ql/definition_helpers/definable'
 require 'graph_ql/definition_helpers/field_definer'
 require 'graph_ql/definition_helpers/non_null_with_bang'
+require 'graph_ql/definition_helpers/defined_by_config'
 require 'graph_ql/definition_helpers/string_named_hash'
 require 'graph_ql/definition_helpers/type_definer'

data/lib/graph_ql/definition_helpers/defined_by_config.rb

@@ -0,0 +1,20 @@
+# Provide a two-step definition process.
+#
+# 1. Use a config object to gather definitions
+# 2. Transfer definitions to an actual instance of an object
+#
+module GraphQL::DefinitionHelpers::DefinedByConfig
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    # Pass the block to this class's `DefinitionConfig`,
+    # The return the result of {DefinitionConfig#to_instance}
+    def define(&block)
+      config = self.const_get(:DefinitionConfig).new
+      block && config.instance_eval(&block)
+      config.to_instance
+    end
+  end
+end

data/lib/graph_ql/enum_type.rb

@@ -3,36 +3,68 @@
 #
 # @example An enum of programming languages
 #
-#   LanguageEnum = GraphQL::EnumType.new do |e|
-#     e.name("Languages")
-#     e.descriptions("Programming languages for Web projects")
-#     e.value("PYTHON", "A dynamic, function-oriented language")
-#     e.value("RUBY", "A very dynamic language aimed at programmer happiness")
-#     e.value("JAVASCRIPT", "Accidental lingua franca of the web")
+#   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
   include GraphQL::DefinitionHelpers::NonNullWithBang
+  include GraphQL::DefinitionHelpers::DefinedByConfig
   extend GraphQL::DefinitionHelpers::Definable
   attr_definable :name, :description
-  attr_reader :values
+  attr_accessor :values
+
+  class DefinitionConfig
+    extend GraphQL::DefinitionHelpers::Definable
+    # These are deprecated:
+    attr_definable :name, :description
+    attr_reader :values
+    def initialize
+      @values = {}
+    end
+
+    def types
+      GraphQL::DefinitionHelpers::TypeDefiner.instance
+    end
+
+    def value(name, desc = nil, deprecation_reason: nil, value: name)
+      value = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
+      values[name] = value
+    end
+
+    def to_instance
+      object = GraphQL::EnumType.new
+      object.name = name
+      object.description = description
+      object.values = values
+      object
+    end
+  end
+
   def initialize
     @values = {}
-    yield(
-      self,
-      GraphQL::DefinitionHelpers::TypeDefiner.instance,
-      GraphQL::DefinitionHelpers::FieldDefiner.instance,
-      GraphQL::DefinitionHelpers::ArgumentDefiner.instance
-    )
+    if block_given?
+      yield(
+        self,
+        GraphQL::DefinitionHelpers::TypeDefiner.instance,
+        GraphQL::DefinitionHelpers::FieldDefiner.instance,
+        GraphQL::DefinitionHelpers::ArgumentDefiner.instance
+      )
+      warn("Initializing with .new is deprecated, use .define instead! (see #{self})")
+    end
   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)
+    values[name] = EnumValue.new(name: name, description: description, deprecation_reason: deprecation_reason, value: value)
   end
 
   def kind
@@ -48,7 +80,11 @@ class GraphQL::EnumType
   # @param value_name [String] the string representation of this enum value
   # @return [Object] the underlying value for this enum value
   def coerce(value_name)
-    @values[value_name].value
+    values[value_name].value
+  end
+
+  def to_s
+    name
   end
 
   # A value within an {EnumType}

data/lib/graph_ql/field.rb

@@ -1,28 +1,83 @@
-# These are valid values for a type's `fields` hash.
+# {Field}s belong to {ObjectType}s and {InterfaceType}s.
+#
+# They're usually created with the `field` helper.
 #
-# You can also use {FieldDefiner#build} to create fields.
 #
 # @example creating a field
-#   name_field = GraphQL::Field.new do |f, types|
-#     f.name("Name")
-#     f.type(!types.String)
-#     f.description("The name of this thing")
-#     f.resolve -> (object, arguments, context) { object.name }
+#   GraphQL::ObjectType.define do
+#     field :name, types.String, "The name of this thing "
+#   end
+#
+# @example creating a field that accesses a different property on the object
+#   GraphQL::ObjectType.define do
+#     # use the `property` option:
+#     field :firstName, types.String, property: :first_name
+#   end
+#
+# @example defining a field, then attaching it to a type
+#   name_field = GraphQL::Field.define do
+#     name("Name")
+#     type(!types.String)
+#     description("The name of this thing")
+#     resolve -> (object, arguments, context) { object.name }
+#   end
+#
+#   NamedType = GraphQL::ObjectType.define do
+#     # use the `field` option:
+#     field :name, field: name_field
 #   end
 #
 class GraphQL::Field
+  DEFAULT_RESOLVE = -> (o, a, c) { GraphQL::Query::DEFAULT_RESOLVE }
+  include GraphQL::DefinitionHelpers::DefinedByConfig
+  # These are deprecated:
   extend GraphQL::DefinitionHelpers::Definable
   attr_definable(:arguments, :deprecation_reason, :name, :description, :type)
 
+  class DefinitionConfig
+    extend GraphQL::DefinitionHelpers::Definable
+    attr_definable :name, :description, :type, :deprecation_reason, :resolve
+    def initialize
+      @arguments = {}
+    end
+
+    def types
+      GraphQL::DefinitionHelpers::TypeDefiner.instance
+    end
+
+    def argument(name, type, description = nil, default_value: nil)
+      @arguments[name.to_s] = GraphQL::Argument.new(
+        name: name.to_s,
+        type: type,
+        description: description,
+        default_value: nil,
+      )
+    end
+
+    def to_instance
+      object = GraphQL::Field.new
+      object.name = name
+      object.type = type
+      object.description = description
+      object.deprecation_reason = deprecation_reason
+      object.resolve = resolve
+      object.arguments = @arguments
+      object
+    end
+  end
+
   def initialize
     @arguments = {}
-    @resolve_proc = -> (o, a, c) { GraphQL::Query::DEFAULT_RESOLVE }
-    yield(
-      self,
-      GraphQL::DefinitionHelpers::TypeDefiner.instance,
-      GraphQL::DefinitionHelpers::FieldDefiner.instance,
-      GraphQL::DefinitionHelpers::ArgumentDefiner.instance
-    )
+    @resolve_proc = DEFAULT_RESOLVE
+    if block_given?
+      yield(
+        self,
+        GraphQL::DefinitionHelpers::TypeDefiner.instance,
+        GraphQL::DefinitionHelpers::FieldDefiner.instance,
+        GraphQL::DefinitionHelpers::ArgumentDefiner.instance
+      )
+      warn("Initializing with .new is deprecated, use .define instead! (see #{self})")
+    end
   end
 
   def arguments(new_arguments=nil)
@@ -38,6 +93,7 @@ class GraphQL::Field
   end
 
   # @overload resolve(definition_proc)
+  #   @deprecated use {.define} API instead
   #   Define this field to return a value with `definition_proc`
   #   @example defining the resolve method
   #     field.resolve -> (obj, args, ctx) { obj.get_value }
@@ -59,7 +115,12 @@ class GraphQL::Field
     end
   end
 
+  def resolve=(resolve_proc)
+    @resolve_proc = resolve_proc || DEFAULT_RESOLVE
+  end
+
   # @overload type(return_type)
+  #   @deprecated use {.define} API instead
   #   Define the return type for this field
   #   @param return_type [GraphQL::ObjectType, GraphQL::ScalarType] The type this field returns
   #
@@ -79,4 +140,8 @@ class GraphQL::Field
     end
     @type
   end
+
+  def to_s
+    "<Field: #{name || "not-named"}>"
+  end
 end

data/lib/graph_ql/float_type.rb

@@ -1,6 +1,6 @@
-GraphQL::FLOAT_TYPE = GraphQL::ScalarType.new do |t|
-  t.name "Float"
-  def t.coerce(value)
+GraphQL::FLOAT_TYPE = GraphQL::ScalarType.define do
+  name "Float"
+  coerce -> (value) do
     value.respond_to?(:to_f) ? value.to_f : nil
   end
 end

data/lib/graph_ql/id_type.rb

@@ -1,6 +1,4 @@
-GraphQL::ID_TYPE = GraphQL::ScalarType.new do |t|
-  t.name "ID"
-  def t.coerce(value)
-    value.to_s
-  end
+GraphQL::ID_TYPE = GraphQL::ScalarType.define do
+  name "ID"
+  coerce -> (value) { value.to_s }
 end

data/lib/graph_ql/input_object_type.rb

@@ -10,9 +10,44 @@
 #   end
 #
 class GraphQL::InputObjectType < GraphQL::ObjectType
+  # Deprecated:
   attr_definable :input_fields
 
+  class DefinitionConfig
+    extend GraphQL::DefinitionHelpers::Definable
+    attr_definable :name, :description, :input_fields
+    def initialize
+      @input_fields = {}
+    end
+
+    def types
+      GraphQL::DefinitionHelpers::TypeDefiner.instance
+    end
+
+    def input_field(name, type = nil, desc = nil, default_value: nil, &block)
+      argument = if block_given?
+        GraphQL::Argument.define(&block)
+      else
+        GraphQL::Argument.new
+      end
+      argument.name = name
+      type && argument.type = type
+      desc && argument.desc = desc
+      default_value && argument.default_value = default_value
+      @input_fields[name.to_s] = argument
+    end
+
+    def to_instance
+      object = GraphQL::InputObjectType.new
+      object.name = name
+      object.description = description
+      object.input_fields = @input_fields
+      object
+    end
+  end
+
   # @overload input_fields(new_fields)
+  #   @deprecated use {.define} API instead
   #   Define allowed fields, normalized with {StringNamedHash}
   #   @param new_fields [Hash] allowed fields for this input object type
   #
@@ -21,10 +56,12 @@ class GraphQL::InputObjectType < GraphQL::ObjectType
   #   @return [Hash] allowed fields for this input object type
   #
   def input_fields(new_fields=nil)
-    if !new_fields.nil?
-      @new_fields = GraphQL::DefinitionHelpers::StringNamedHash.new(new_fields).to_h
-    end
-    @new_fields
+    new_fields && self.input_fields = new_fields
+    @input_fields
+  end
+
+  def input_fields=(new_fields)
+    @input_fields = GraphQL::DefinitionHelpers::StringNamedHash.new(new_fields).to_h
   end
 
   def kind

data/lib/graph_ql/int_type.rb

@@ -1,6 +1,4 @@
-GraphQL::INT_TYPE = GraphQL::ScalarType.new do |t|
-  t.name "Int"
-  def t.coerce(value)
-    value.is_a?(Numeric) ? value.to_i : nil
-  end
+GraphQL::INT_TYPE = GraphQL::ScalarType.define do
+  name "Int"
+  coerce -> (value) { value.is_a?(Numeric) ? value.to_i : nil }
 end

data/lib/graph_ql/interface_type.rb

@@ -1,14 +1,13 @@
 # A collection of types which implement the same fields
 #
 # @example An interface with three required fields
-#   DeviceInterface = GraphQL::InterfaceType.new do |i, types, fields|
-#     i.name("Device")
-#     i.description("Hardware devices for computing")
-#     i.fields({
-#       ram:          fields.build(type: types.String),
-#       processor:    fields.build(type: ProcessorType),
-#       release_year: fields.build(type: types.Int),
-#     })
+#   DeviceInterface = GraphQL::InterfaceType.define do
+#     name("Device")
+#     description("Hardware devices for computing")
+#
+#     field :ram, types.String
+#     field :processor, ProcessorType
+#     field :release_year, types.Int
 #   end
 #
 class GraphQL::InterfaceType < GraphQL::ObjectType
@@ -16,6 +15,35 @@ class GraphQL::InterfaceType < GraphQL::ObjectType
     GraphQL::TypeKinds::INTERFACE
   end
 
+  class DefinitionConfig
+    extend GraphQL::DefinitionHelpers::Definable
+    attr_definable :name, :description
+
+    def initialize
+      @fields = {}
+    end
+
+    def types
+      GraphQL::DefinitionHelpers::TypeDefiner.instance
+    end
+
+    def field(name, type = nil, desc = nil, property: nil, field: nil, &block)
+      field ||= GraphQL::Field.define(&block)
+      type && field.type = type
+      desc && field.description = desc
+      field.name ||= name.to_s
+      @fields[name.to_s] = field
+    end
+
+    def to_instance
+      object = GraphQL::InterfaceType.new
+      object.name = name
+      object.description = description
+      object.fields = @fields
+      object
+    end
+  end
+
   # @return [Array<GraphQL::ObjectType>] Types which declare that they implement this interface
   def possible_types
     @possible_types ||= []