graphql 1.0.0 → 1.1.0

data/lib/graphql/define/instance_definable.rb

@@ -56,17 +56,23 @@ module GraphQL
     #   # Access it from metadata
     #   subaru_baja.metadata[:all_wheel_drive] # => true
     #
+    # @example Making a copy with an extended definition
+    #   # Create an instance with `.define`:
+    #   subaru_baja = Car.define do
+    #     make "Subaru"
+    #     model "Baja"
+    #     doors 4
+    #   end
+    #
+    #   # Then extend it with `#redefine`
+    #   two_door_baja = subaru_baja.redefine do
+    #     doors 2
+    #   end
     module InstanceDefinable
       def self.included(base)
         base.extend(ClassMethods)
       end
 
-      # Set the definition block for this instance.
-      # It can be run later with {#ensure_defined}
-      def definition_proc=(defn_block)
-        @definition_proc = defn_block
-      end
-
       # `metadata` can store arbitrary key-values with an object.
       #
       # @return [Hash<Object, Object>] Hash for user-defined storage
@@ -84,19 +90,21 @@ module GraphQL
       def define(**kwargs, &block)
         # make sure the previous definition_proc was executed:
         ensure_defined
-
-        @definition_proc = ->(obj) {
-          kwargs.each do |keyword, value|
-            public_send(keyword, value)
-          end
-
-          if block
-            instance_eval(&block)
-          end
-        }
+        @pending_definition = Definition.new(kwargs, block)
         nil
       end
 
+      # Make a new instance of this class, then
+      # re-run any definitions on that object.
+      # @return [InstanceDefinable] A new instance, with any extended definitions
+      def redefine(**kwargs, &block)
+        ensure_defined
+        new_instance = self.class.new
+        applied_definitions.each { |defn| defn.apply(new_instance) }
+        new_instance.define(**kwargs, &block)
+        new_instance
+      end
+
       private
 
       # Run the definition block if it hasn't been run yet.
@@ -105,15 +113,39 @@ module GraphQL
       # come from the definition block.
       # @return [void]
       def ensure_defined
-        if @definition_proc
-          defn_proc = @definition_proc
-          @definition_proc = nil
-          proxy = DefinedObjectProxy.new(self)
-          proxy.instance_eval(&defn_proc)
+        if @pending_definition
+          defn = @pending_definition
+          @pending_definition = nil
+          defn.apply(self)
+          applied_definitions << defn
         end
         nil
       end
 
+      def applied_definitions
+        @applied_definitions ||= []
+      end
+
+
+      class Definition
+        def initialize(define_keywords, define_proc)
+          @define_keywords = define_keywords
+          @define_proc = define_proc
+        end
+
+        def apply(instance)
+          defn_proxy = DefinedObjectProxy.new(instance)
+
+          @define_keywords.each do |keyword, value|
+            defn_proxy.public_send(keyword, value)
+          end
+
+          if @define_proc
+            defn_proxy.instance_eval(&@define_proc)
+          end
+        end
+      end
+
       module ClassMethods
         # Create a new instance
         # and prepare a definition using its {.definitions}.

data/lib/graphql/directive.rb

@@ -7,7 +7,7 @@ module GraphQL
   #
   class Directive
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :locations, :name, :description, argument: GraphQL::Define::AssignArgument
+    accepts_definitions :locations, :name, :description, :arguments, argument: GraphQL::Define::AssignArgument
 
     lazy_defined_attr_accessor :locations, :arguments, :name, :description
 

data/lib/graphql/enum_type.rb

@@ -55,25 +55,37 @@ module GraphQL
   #     args[:favoriteLanguage] # => :rb
   #   }
   #
+  # @example Enum whose values are different in ActiveRecord-land
+  #   class Language < ActiveRecord::BaseType
+  #     enum language: {
+  #       rb: 0
+  #     }
+  #   end
+  #
+  #   # Now enum type should be defined as
+  #   GraphQL::EnumType.define do
+  #     # ...
+  #     # use the `value:` keyword:
+  #     value("RUBY", "Lisp? Smalltalk?", value: 'rb')
+  #   end
+  #
+
   class EnumType < GraphQL::BaseType
     accepts_definitions :values, value: GraphQL::Define::AssignEnumValue
 
     def initialize
       @values_by_name = {}
-      @values_by_value = {}
     end
 
     # @param new_values [Array<EnumValue>] The set of values contained in this type
     def values=(new_values)
       @values_by_name = {}
-      @values_by_value = {}
       new_values.each { |enum_value| add_value(enum_value) }
     end
 
     # @param enum_value [EnumValue] A value to add to this type's set of values
     def add_value(enum_value)
       @values_by_name[enum_value.name] = enum_value
-      @values_by_value[enum_value.value] = enum_value
     end
 
     # @return [Hash<String => EnumValue>] `{name => value}` pairs contained in this type
@@ -86,12 +98,14 @@ module GraphQL
       GraphQL::TypeKinds::ENUM
     end
 
-    def validate_non_null_input(value_name)
+    def validate_non_null_input(value_name, warden)
       ensure_defined
       result = GraphQL::Query::InputValidationResult.new
+      allowed_values = warden.enum_values(self)
+      matching_value = allowed_values.find { |v| v.name == value_name }
 
-      if !@values_by_name.key?(value_name)
-        result.add_problem("Expected #{JSON.generate(value_name, quirks_mode: true)} to be one of: #{@values_by_name.keys.join(', ')}")
+      if matching_value.nil?
+        result.add_problem("Expected #{JSON.generate(value_name, quirks_mode: true)} to be one of: #{allowed_values.join(', ')}")
       end
 
       result
@@ -114,9 +128,15 @@ module GraphQL
       end
     end
 
-    def coerce_result(value)
+    def coerce_result(value, warden = nil)
       ensure_defined
-      @values_by_value.fetch(value).name
+      all_values = warden ? warden.enum_values(self) : @values_by_name.each_value
+      enum_value = all_values.find { |val| val.value == value }
+      if enum_value
+        enum_value.name
+      else
+        raise(UnresolvedValueError, "Can't resolve enum #{name} for #{value}")
+      end
     end
 
     def to_s
@@ -132,5 +152,8 @@ module GraphQL
 
       lazy_defined_attr_accessor :name, :description, :deprecation_reason, :value
     end
+
+    class UnresolvedValueError < GraphQL::Error
+    end
   end
 end

data/lib/graphql/execution/directive_checks.rb

@@ -8,12 +8,6 @@ module GraphQL
 
       module_function
 
-      # This covers `@include(if:)` & `@skip(if:)`
-      # @return [Boolean] Should this node be skipped altogether?
-      def skip?(ast_node, query)
-        !include?(ast_node, query)
-      end
-
       # @return [Boolean] Should this node be included in the query?
       def include?(directive_irep_nodes, query)
         directive_irep_nodes.each do |directive_irep_node|

data/lib/graphql/input_object_type.rb

@@ -47,19 +47,21 @@ module GraphQL
       GraphQL::TypeKinds::INPUT_OBJECT
     end
 
-    def validate_non_null_input(input)
+    def validate_non_null_input(input, warden)
       result = GraphQL::Query::InputValidationResult.new
 
+      visible_arguments_map = warden.input_fields(self).reduce({}) { |m, f| m[f.name] = f; m}
+
       # Items in the input that are unexpected
       input.each do |name, value|
-        if arguments[name].nil?
+        if visible_arguments_map[name].nil?
           result.add_problem("Field is not defined on #{self.name}", [name])
         end
       end
 
       # Items in the input that are expected, but have invalid values
-      invalid_fields = arguments.map do |name, field|
-        field_result = field.type.validate_input(input[name])
+      invalid_fields = visible_arguments_map.map do |name, field|
+        field_result = field.type.validate_input(input[name], warden)
         if !field_result.valid?
           result.merge_result!(name, field_result)
         end

data/lib/graphql/introspection/arguments_field.rb

@@ -1,4 +1,6 @@
 GraphQL::Introspection::ArgumentsField = GraphQL::Field.define do
   type !GraphQL::ListType.new(of_type: !GraphQL::Introspection::InputValueType)
-  resolve ->(target, a, c) { target.arguments.values }
+  resolve ->(obj, args, ctx) {
+    ctx.warden.arguments(obj)
+  }
 end

data/lib/graphql/introspection/enum_values_field.rb

@@ -2,11 +2,16 @@ GraphQL::Introspection::EnumValuesField = GraphQL::Field.define do
   type types[!GraphQL::Introspection::EnumValueType]
   argument :includeDeprecated, types.Boolean, default_value: false
   resolve ->(object, arguments, context) do
-    return nil if !object.kind.enum?
-    fields = object.values.values
-    if !arguments["includeDeprecated"]
-      fields = fields.select {|f| !f.deprecation_reason }
+    if !object.kind.enum?
+      nil
+    else
+      enum_values = context.warden.enum_values(object)
+
+      if !arguments["includeDeprecated"]
+        enum_values = enum_values.select {|f| !f.deprecation_reason }
+      end
+
+      enum_values
     end
-    fields
   end
 end

data/lib/graphql/introspection/fields_field.rb

@@ -3,7 +3,7 @@ GraphQL::Introspection::FieldsField = GraphQL::Field.define do
   argument :includeDeprecated, GraphQL::BOOLEAN_TYPE, default_value: false
   resolve ->(object, arguments, context) {
     return nil if !object.kind.fields?
-    fields = object.all_fields
+    fields = context.warden.fields(object)
     if !arguments["includeDeprecated"]
       fields = fields.select {|f| !f.deprecation_reason }
     end

data/lib/graphql/introspection/input_fields_field.rb

@@ -1,9 +1,9 @@
 GraphQL::Introspection::InputFieldsField = GraphQL::Field.define do
   name "inputFields"
   type types[!GraphQL::Introspection::InputValueType]
-  resolve ->(target, a, c) {
+  resolve ->(target, a, ctx) {
     if target.kind.input_object?
-      target.input_fields.values
+      ctx.warden.input_fields(target)
     else
       nil
     end

data/lib/graphql/introspection/interfaces_field.rb

@@ -1,4 +1,10 @@
 GraphQL::Introspection::InterfacesField = GraphQL::Field.define do
   type -> { types[!GraphQL::Introspection::TypeType] }
-  resolve ->(target, a, c) { target.kind.object? ? target.interfaces : nil }
+  resolve ->(target, a, ctx) {
+    if target.kind == GraphQL::TypeKinds::OBJECT
+      ctx.warden.interfaces(target)
+    else
+      nil
+    end
+  }
 end

data/lib/graphql/introspection/possible_types_field.rb

@@ -2,7 +2,7 @@ GraphQL::Introspection::PossibleTypesField = GraphQL::Field.define do
   type -> { types[!GraphQL::Introspection::TypeType] }
   resolve ->(target, args, ctx) {
     if target.kind.resolves?
-      ctx.schema.possible_types(target)
+      ctx.warden.possible_types(target)
     else
       nil
     end

data/lib/graphql/introspection/schema_type.rb

@@ -5,7 +5,7 @@ GraphQL::Introspection::SchemaType = GraphQL::ObjectType.define do
               "query, mutation, and subscription operations."
 
   field :types, !types[!GraphQL::Introspection::TypeType], "A list of all types supported by this server." do
-    resolve ->(obj, arg, ctx) { obj.types.values }
+    resolve -> (obj, arg, ctx) { ctx.warden.types }
   end
 
   field :queryType, !GraphQL::Introspection::TypeType, "The type that query operations will be rooted at." do

data/lib/graphql/introspection/type_by_name_field.rb

@@ -2,13 +2,15 @@ module GraphQL
   module Introspection
     # A wrapper to create `__type(name: )` dynamically.
     class TypeByNameField
-      def self.create(type_hash)
+      def self.create(schema)
         GraphQL::Field.define do
           name("__type")
           description("A type in the GraphQL system")
           type(GraphQL::Introspection::TypeType)
           argument :name, !types.String
-          resolve ->(o, args, c) { type_hash.fetch(args["name"], nil) }
+          resolve ->(o, args, ctx) {
+            ctx.warden.get_type(args["name"])
+          }
         end
       end
     end

data/lib/graphql/introspection/type_type.rb

@@ -12,12 +12,13 @@ GraphQL::Introspection::TypeType = GraphQL::ObjectType.define do
     type !GraphQL::Introspection::TypeKindEnum
     resolve ->(target, a, c) { target.kind.name }
   end
+
   field :name, types.String
   field :description, types.String
-  field :fields,          field: GraphQL::Introspection::FieldsField
-  field :interfaces,      field: GraphQL::Introspection::InterfacesField
-  field :possibleTypes,   field: GraphQL::Introspection::PossibleTypesField
-  field :enumValues,      field: GraphQL::Introspection::EnumValuesField
-  field :inputFields,     field: GraphQL::Introspection::InputFieldsField
-  field :ofType,          field: GraphQL::Introspection::OfTypeField
+  field :fields,        GraphQL::Introspection::FieldsField
+  field :interfaces,    GraphQL::Introspection::InterfacesField
+  field :possibleTypes, GraphQL::Introspection::PossibleTypesField
+  field :enumValues,    GraphQL::Introspection::EnumValuesField
+  field :inputFields,   GraphQL::Introspection::InputFieldsField
+  field :ofType,        GraphQL::Introspection::OfTypeField
 end

data/lib/graphql/language/lexer.rl

@@ -109,7 +109,6 @@ module GraphQL
       # 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
 
@@ -178,9 +177,6 @@ module GraphQL
         "\\t" => "\t",
       }
 
-      UTF_8 = /\\u[\dAa-f]{4}/i
-      UTF_8_REPLACE = ->(m) { [m[-4..-1].to_i(16)].pack('U'.freeze) }
-
       def self.emit_string(ts, te, meta)
         value = meta[:data][ts...te].pack("c*").force_encoding("UTF-8")
         if value =~ /\\u|\\./ && value !~ ESCAPES

data/lib/graphql/language/parser.rb

@@ -20,7 +20,7 @@ end
 
 def parse_document
   @document ||= begin
-    @tokens ||= GraphQL::Language::Lexer.tokenize(@query_string)
+    @tokens ||= GraphQL.scan(@query_string)
     if @tokens.none?
       make_node(:Document, definitions: [])
     else

data/lib/graphql/language/parser.y

@@ -348,7 +348,7 @@ end
 
 def parse_document
   @document ||= begin
-    @tokens ||= GraphQL::Language::Lexer.tokenize(@query_string)
+    @tokens ||= GraphQL.scan(@query_string)
     if @tokens.none?
       make_node(:Document, definitions: [])
     else

data/lib/graphql/list_type.rb

@@ -25,9 +25,8 @@ module GraphQL
   #
   class ListType < GraphQL::BaseType
     include GraphQL::BaseType::ModifiesAnotherType
-    attr_reader :of_type, :name
+    attr_reader :of_type
     def initialize(of_type:)
-      @name = "List"
       @of_type = of_type
     end
 
@@ -39,11 +38,11 @@ module GraphQL
       "[#{of_type.to_s}]"
     end
 
-    def validate_non_null_input(value)
+    def validate_non_null_input(value, warden)
       result = GraphQL::Query::InputValidationResult.new
 
       ensure_array(value).each_with_index do |item, index|
-        item_result = of_type.validate_input(item)
+        item_result = of_type.validate_input(item, warden)
         if !item_result.valid?
           result.merge_result!(index, item_result)
         end

data/lib/graphql/non_null_type.rb

@@ -35,21 +35,17 @@ module GraphQL
       @of_type = of_type
     end
 
-    def name
-      "Non-Null"
+    def valid_input?(value, warden)
+      validate_input(value, warden).valid?
     end
 
-    def valid_input?(value)
-      validate_input(value).valid?
-    end
-
-    def validate_input(value)
+    def validate_input(value, warden)
       if value.nil?
         result = GraphQL::Query::InputValidationResult.new
         result.add_problem("Expected value to not be null")
         result
       else
-        of_type.validate_input(value)
+        of_type.validate_input(value, warden)
       end
     end