graphql 0.10.0 → 0.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cb8700392b11bc4b4e577e38b424c13b3d33dd9
-  data.tar.gz: 36f2b6d48b2d11084aeb4d0ea50c194e1f2a4b27
+  metadata.gz: 5651b5fa2ec7dde473a9747b9899bcb99a71b1d5
+  data.tar.gz: a3c045b8d41109f2867090f68c0868eb68671d55
 SHA512:
-  metadata.gz: c8498188be3457f626d74653e48bee19558fc3030f383d8fe65cdf3cfa7f0cf9c8eeabafb1de634a48f9f991de77a0e2630056356de5854af78adbc03881cc14
-  data.tar.gz: de3a1fcfdecefe84e9ed578c9840e861670df763dfb7bd96b11e97e7971c6cbd10c669674cc574904ae9fd0b0db29d70f3dac1bf2aa1f3e430320067dd88859a
+  metadata.gz: e4ca9364a51bc9d85927d3a00f9d06514a386a482078366167f647eb483455d0bb052041a921f0c107e84cb872a26343d26684c6c625a5fcc8ba19132191ffae
+  data.tar.gz: 6c60beeafb45f1246293c4aa559e04a0240ca1e2a9d82f3323f3a34320bd2d5703f3b38aa647ad21b57128a9121cb9ec2a1c213dd0d42400a1bce801a3da31f0

data/lib/graphql/base_type.rb

@@ -76,18 +76,14 @@ module GraphQL
 
     alias :inspect :to_s
 
-    # Coerce `input_value` according to this type's `coerce` method.
-    # Raise an error if the value becomes nil.
-    # @param [Object] Incoming query value
-    # @return [Object] Coerced value for query execution
-    def coerce_input!(input_value)
-      coerced_value = coerce_input(input_value)
-
-      if coerced_value.nil?
-        raise GraphQL::ExecutionError.new("Couldn't coerce #{input_value.inspect} to #{self.unwrap.name}")
-      end
+    def valid_input?(value)
+      return true if value.nil?
+      valid_non_null_input?(value)
+    end
 
-      coerced_value
+    def coerce_input(value)
+      return nil if value.nil?
+      coerce_non_null_input(value)
     end
   end
 end

data/lib/graphql/enum_type.rb

@@ -41,6 +41,10 @@ class GraphQL::EnumType < GraphQL::BaseType
     GraphQL::TypeKinds::ENUM
   end
 
+  def valid_non_null_input?(value_name)
+    @values_by_name.key?(value_name)
+  end
+
   # Get the underlying value for this enum value
   #
   # @example get episode value from Enum
@@ -49,7 +53,7 @@ class GraphQL::EnumType < GraphQL::BaseType
   #
   # @param value_name [String] the string representation of this enum value
   # @return [Object] the underlying value for this enum value
-  def coerce_input(value_name)
+  def coerce_non_null_input(value_name)
     @values_by_name.fetch(value_name).value
   end
 

data/lib/graphql/input_object_type.rb

@@ -19,12 +19,21 @@ class GraphQL::InputObjectType < GraphQL::BaseType
     GraphQL::TypeKinds::INPUT_OBJECT
   end
 
-  def coerce_input(value)
+  def valid_non_null_input?(input)
+    return false unless input.is_a?(Hash) || input.is_a?(GraphQL::Query::Arguments)
+    return false unless input.all? { |name, value| input_fields[name] }
+    input_fields.all? { |name, field| field.type.valid_input?(input[name]) }
+  end
+
+  def coerce_non_null_input(value)
     input_values = {}
     input_fields.each do |input_key, input_field_defn|
-      raw_value = value.fetch(input_key, input_field_defn.default_value)
-      field_type = input_field_defn.type
-      input_values[input_key] = field_type.coerce_input!(raw_value)
+      field_value = value[input_key]
+      field_value = input_field_defn.type.coerce_input(field_value)
+      if field_value.nil?
+        field_value = input_field_defn.default_value
+      end
+      input_values[input_key] = field_value unless field_value.nil?
     end
     GraphQL::Query::Arguments.new(input_values)
   end

data/lib/graphql/list_type.rb

@@ -17,8 +17,12 @@ class GraphQL::ListType < GraphQL::BaseType
     "[#{of_type.to_s}]"
   end
 
-  def coerce_input(value)
-    inner_type = of_type
-    value.map { |item| inner_type.coerce_input!(item) }
+  def valid_non_null_input?(value)
+    return false unless value.is_a?(Array)
+    value.all?{ |item| of_type.valid_input?(item) }
+  end
+
+  def coerce_non_null_input(value)
+    value.map{ |item| of_type.coerce_input(item) }
   end
 end

data/lib/graphql/non_null_type.rb

@@ -13,6 +13,10 @@ class GraphQL::NonNullType < GraphQL::BaseType
     "Non-Null"
   end
 
+  def valid_input?(value)
+    !value.nil? && of_type.valid_input?(value)
+  end
+
   def coerce_input(value)
     of_type.coerce_input(value)
   end

data/lib/graphql/query.rb

@@ -6,10 +6,17 @@ class GraphQL::Query
     end
   end
 
-  class VariableMissingError < StandardError
-    def initialize(name, type)
-      msg = "Variable #{name} of type #{type} can't be null"
+  class VariableValidationError < GraphQL::ExecutionError
+    def initialize(variable_ast, type, reason)
+      msg = "Variable #{variable_ast.name} of type #{type} #{reason}"
       super(msg)
+      self.ast_node = variable_ast
+    end
+  end
+
+  class VariableMissingError < VariableValidationError
+    def initialize(variable_ast, type)
+      super(variable_ast, type, "can't be null")
     end
   end
 
@@ -102,7 +109,6 @@ require 'graphql/query/context'
 require 'graphql/query/directive_chain'
 require 'graphql/query/executor'
 require 'graphql/query/literal_input'
-require 'graphql/query/ruby_input'
 require 'graphql/query/serial_execution'
 require 'graphql/query/type_resolver'
 require 'graphql/query/variables'

data/lib/graphql/query/arguments.rb

@@ -8,7 +8,7 @@ module GraphQL
 
       def initialize(values)
         @values = values.inject({}) do |memo, (inner_key, inner_value)|
-          memo[inner_key] = wrap_value(inner_value)
+          memo[inner_key.to_s] = wrap_value(inner_value)
           memo
         end
       end
@@ -19,7 +19,7 @@ module GraphQL
         @values[key.to_s]
       end
 
-      def_delegators :@values_hash, :keys, :values, :each
+      def_delegators :@values, :keys, :values, :each
 
       private
 

data/lib/graphql/query/executor.rb

@@ -13,7 +13,9 @@ module GraphQL
       # @return [Hash] A GraphQL response, with either a "data" key or an "errors" key
       def result
         execute
-      rescue GraphQL::Query::OperationNameMissingError, GraphQL::Query::VariableMissingError => err
+      rescue GraphQL::ExecutionError => err
+        {"errors" => [err.to_h]}
+      rescue GraphQL::Query::OperationNameMissingError => err
         {"errors" => [{"message" => err.message}]}
       rescue StandardError => err
         query.debug && raise(err)

data/lib/graphql/query/literal_input.rb

@@ -2,47 +2,16 @@ module GraphQL
   class Query
     # Turn query string values into something useful for query execution
     class LiteralInput
-      attr_reader :variables, :value, :type
-      def initialize(type, incoming_value, variables)
-        @type = type
-        @value = incoming_value
-        @variables = variables
-      end
-
-      def graphql_value
-        if value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          variables[value.name] # Already cleaned up with RubyInput
-        elsif type.kind.input_object?
-          input_values = {}
-          inner_type = type.unwrap
-          inner_type.input_fields.each do |arg_name, arg_defn|
-            ast_arg = value.pairs.find { |ast_arg| ast_arg.name == arg_name }
-            raw_value = resolve_argument_value(ast_arg, arg_defn, variables)
-            reduced_value = coerce(arg_defn.type, raw_value, variables)
-            input_values[arg_name] = reduced_value
-          end
-          input_values
-        elsif type.kind.list?
-          inner_type = type.of_type
-          value.map { |item| coerce(inner_type, item, variables) }
-        elsif type.kind.non_null?
-          inner_type = type.of_type
-          coerce(inner_type, value, variables)
-        elsif type.kind.scalar?
-          type.coerce_input!(value)
-        elsif type.kind.enum?
-          value_name = value.name # it's a Nodes::Enum
-          type.coerce_input!(value_name)
+      def self.coerce(type, value, variables)
+        if value.is_a?(Language::Nodes::VariableIdentifier)
+          variables[value.name]
+        elsif value.nil?
+          nil
         else
-          raise "Unknown input #{value} of type #{type}"
+          LiteralKindCoercers::STRATEGIES.fetch(type.kind).coerce(value, type, variables)
         end
       end
 
-      def self.coerce(type, value, variables)
-        input = self.new(type, value, variables)
-        input.graphql_value
-      end
-
       def self.from_arguments(ast_arguments, argument_defns, variables)
         values_hash = {}
         argument_defns.each do |arg_name, arg_defn|
@@ -59,31 +28,61 @@ module GraphQL
         GraphQL::Query::Arguments.new(values_hash)
       end
 
-      private
+      module LiteralKindCoercers
+        module NonNullLiteral
+          def self.coerce(value, type, variables)
+            LiteralInput.coerce(type.of_type, value, variables)
+          end
+        end
 
-      def coerce(*args)
-        self.class.coerce(*args)
-      end
+        module ListLiteral
+          def self.coerce(value, type, variables)
+            if value.is_a?(Array)
+              value.map{ |element_ast| LiteralInput.coerce(type.of_type, element_ast, variables) }
+            else
+              [LiteralInput.coerce(type.of_type, value, variables)]
+            end
+          end
+        end
 
-      def resolve_argument_value(*args)
-        self.class.resolve_argument_value(*args)
-      end
+        module InputObjectLiteral
+          def self.coerce(value, type, variables)
+            hash = {}
+            value.pairs.each do |arg|
+              field_type = type.input_fields[arg.name].type
+              hash[arg.name] = LiteralInput.coerce(field_type, arg.value, variables)
+            end
+            type.input_fields.each do |arg_name, arg_defn|
+              if hash[arg_name].nil?
+                value = LiteralInput.coerce(arg_defn.type, arg_defn.default_value, variables)
+                hash[arg_name] = value unless value.nil?
+              end
+            end
+            Arguments.new(hash)
+          end
+        end
 
-      # Prefer values in this order:
-      # - Literal value from the query string
-      # - Variable value from query varibles
-      # - Default value from Argument definition
-      def self.resolve_argument_value(ast_arg, arg_defn, variables)
-        if !ast_arg.nil?
-          raw_value = ast_arg.value
+        module EnumLiteral
+          def self.coerce(value, type, variables)
+            type.coerce_input(value.name)
+          end
         end
 
-        if raw_value.nil?
-          raw_value = arg_defn.default_value
+        module ScalarLiteral
+          def self.coerce(value, type, variables)
+            type.coerce_input(value)
+          end
         end
 
-        raw_value
+        STRATEGIES = {
+          TypeKinds::NON_NULL =>     NonNullLiteral,
+          TypeKinds::LIST =>         ListLiteral,
+          TypeKinds::INPUT_OBJECT => InputObjectLiteral,
+          TypeKinds::ENUM =>         EnumLiteral,
+          TypeKinds::SCALAR =>       ScalarLiteral,
+        }
       end
+      private_constant :LiteralKindCoercers
     end
   end
 end

data/lib/graphql/query/serial_execution/selection_resolution.rb

@@ -19,14 +19,10 @@ module GraphQL
           # Then, In a second pass, we resolve the flattened set of fields
           selections
             .reduce({}){|memo, ast_node|
-              flatten_selection(ast_node).each do |name, selection|
-                if memo.has_key? name
-                  memo[name] = merge_fields(memo[name], selection)
-                else
-                  memo[name] = selection
-                end
+              flattened_selections = flatten_selection(ast_node)
+              flattened_selections.each do |name, selection|
+                merge_into_result(memo, selection)
               end
-
               memo
             }
             .values
@@ -38,28 +34,49 @@ module GraphQL
         private
 
         def flatten_selection(ast_node)
-          return {(ast_node.alias || ast_node.name) => ast_node} if ast_node.is_a?(GraphQL::Language::Nodes::Field)
+          strategy_method = STRATEGIES[ast_node.class]
+          send(strategy_method, ast_node)
+        end
+
+        STRATEGIES = {
+          GraphQL::Language::Nodes::Field => :flatten_field,
+          GraphQL::Language::Nodes::InlineFragment => :flatten_inline_fragment,
+          GraphQL::Language::Nodes::FragmentSpread => :flatten_fragment_spread,
+        }
 
-          ast_fragment = get_fragment(ast_node)
-          return {} unless fragment_type_can_apply?(ast_fragment)
+        def flatten_field(ast_node)
+          result_name = ast_node.alias || ast_node.name
+          return { result_name => ast_node }
+        end
 
+        def flatten_inline_fragment(ast_node)
           chain = GraphQL::Query::DirectiveChain.new(ast_node, query) {
-            ast_fragment.selections.reduce({}) do |memo, selection|
-              memo.merge(flatten_selection(selection))
-            end
+            flatten_fragment(ast_node)
           }
+          chain.result
+        end
 
-          chain.result || {}
+        def flatten_fragment_spread(ast_node)
+          ast_fragment_defn = query.fragments[ast_node.name]
+          chain = GraphQL::Query::DirectiveChain.new(ast_node, query) {
+            flatten_fragment(ast_fragment_defn)
+          }
+          chain.result
         end
 
-        def get_fragment(ast_node)
-          if ast_node.is_a? GraphQL::Language::Nodes::FragmentSpread
-            query.fragments[ast_node.name]
-          elsif ast_node.is_a? GraphQL::Language::Nodes::InlineFragment
-            ast_node
-          else
-            raise 'Unrecognized fragment node'
+        def flatten_fragment(ast_fragment)
+          if !fragment_type_can_apply?(ast_fragment)
+            return {}
           end
+
+          flat_result = {}
+          ast_fragment.selections.each do |selection|
+            flat_selection = flatten_selection(selection)
+            flat_selection.each do |name, selection|
+              merge_into_result(flat_result, selection)
+            end
+          end
+          flat_result
         end
 
         def fragment_type_can_apply?(ast_fragment)
@@ -93,6 +110,20 @@ module GraphQL
           }
           chain.result
         end
+
+        def merge_into_result(memo, selection)
+          name = if selection.respond_to?(:alias)
+            selection.alias || selection.name
+          else
+            selection.name
+          end
+
+          if memo.has_key?(name)
+            memo[name] = merge_fields(memo[name], selection)
+          else
+            memo[name] = selection
+          end
+        end
       end
     end
   end

data/lib/graphql/query/variables.rb

@@ -26,12 +26,18 @@ module GraphQL
         variable_name = ast_variable.name
         default_value = ast_variable.default_value
         provided_value = @provided_variables[variable_name]
-        if !provided_value.nil?
-          graphql_value = GraphQL::Query::RubyInput.coerce(variable_type, provided_value)
-        elsif !default_value.nil?
-          graphql_value = GraphQL::Query::LiteralInput.coerce(variable_type, default_value, {})
-        elsif variable_type.kind.non_null?
-          raise GraphQL::Query::VariableMissingError.new(variable_name, variable_type)
+
+        unless variable_type.valid_input?(provided_value)
+          if provided_value.nil?
+            raise GraphQL::Query::VariableMissingError.new(ast_variable, variable_type)
+          else
+            raise GraphQL::Query::VariableValidationError.new(ast_variable, variable_type, "was provided invalid value #{JSON.dump(provided_value)}")
+          end
+        end
+        if provided_value.nil?
+          GraphQL::Query::LiteralInput.coerce(variable_type, default_value, {})
+        else
+          variable_type.coerce_input(provided_value)
         end
       end
     end

data/lib/graphql/scalar_type.rb

@@ -2,7 +2,7 @@ module GraphQL
   # The parent type for scalars, eg {GraphQL::STRING_TYPE}, {GraphQL::INT_TYPE}
   #
   # @example defining a type for Time
-  #   TimeType = GraphQL::ObjectType.define do
+  #   TimeType = GraphQL::ScalarType.define do
   #     name "Time"
   #     description "Time since epoch in seconds"
   #
@@ -19,7 +19,11 @@ module GraphQL
       self.coerce_result = proc
     end
 
-    def coerce_input(value)
+    def valid_non_null_input?(value)
+      !coerce_non_null_input(value).nil?
+    end
+
+    def coerce_non_null_input(value)
       @coerce_input_proc.call(value)
     end
 

data/lib/graphql/static_validation/literal_validator.rb

@@ -6,10 +6,10 @@ class GraphQL::StaticValidation::LiteralValidator
     elsif type.kind.list? && ast_value.is_a?(Array)
       item_type = type.of_type
       ast_value.all? { |val| validate(val, item_type) }
-    elsif type.kind.scalar?
-      !type.coerce_input(ast_value).nil?
+    elsif type.kind.scalar? && !ast_value.is_a?(GraphQL::Language::Nodes::AbstractNode) && !ast_value.is_a?(Array)
+      type.valid_input?(ast_value)
     elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-      !type.coerce_input(ast_value.name).nil?
+      type.valid_input?(ast_value.name)
     elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
       fields = type.input_fields
       ast_value.pairs.all? do |value|
@@ -18,7 +18,6 @@ class GraphQL::StaticValidation::LiteralValidator
         present_if_required && validate(value.value, field_type)
       end
     elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-      # Todo: somehow pass in the document's variable definitions and validate this
       true
     else
       false

data/lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -17,7 +17,7 @@ class GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTyped
     else
       type = context.schema.type_from_ast(node.type)
       if !literal_validator.validate(value, type)
-        context.errors << message("Default value for $#{node.name} doesn't match type #{node.type.name}", node)
+        context.errors << message("Default value for $#{node.name} doesn't match type #{type}", node)
       end
     end
   end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.10.0"
+  VERSION = "0.10.1"
 end

data/readme.md

@@ -109,6 +109,13 @@ If you're building a backend for [Relay](http://facebook.github.io/relay/), you'
 - Big ideas:
   - Use [graphql-parser](https://github.com/shopify/graphql-parser) (Ruby bindings for [libgraphqlparser](https://github.com/graphql/libgraphqlparser)) instead of Parslet
   - Revamp the fixture Schema to be more useful (better names, more extensible)
+  - __Subscriptions__
+    - This is a good chance to make an `Operation` abstraction of which `query`, `mutation` and `subscription` are members
+    - For a subscription, `graphql` would send an outbound message to the system (allow the host application to manage its own subscriptions via Pusher, ActionCable, whatever)
+  - Pre-process query strings?
+    - Remove `@skip`-ed things
+    - Inline any fragments
+    - Inline variables?
 
 ## Goals
 

data/spec/graphql/list_type_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe GraphQL::ListType do
+  let(:float_list) { GraphQL::ListType.new(of_type: GraphQL::FLOAT_TYPE) }
+
+  it 'coerces elements in the list' do
+    assert_equal([1.0, 2.0, 3.0].inspect, float_list.coerce_input([1, 2, 3]).inspect)
+  end
+end

data/spec/graphql/query/arguments_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe GraphQL::Query::Arguments do
+  let(:arguments) { GraphQL::Query::Arguments.new({ a: 1, b: 2 }) }
+
+  it 'returns keys as strings' do
+    assert_equal(['a', 'b'], arguments.keys)
+  end
+
+  it 'delegates values to values hash' do
+    assert_equal([1, 2], arguments.values)
+  end
+
+  it 'delegates each to values hash' do
+    pairs = []
+    arguments.each do |key, value|
+      pairs << [key, value]
+    end
+    assert_equal([['a', 1], ['b', 2]], pairs)
+  end
+end

data/spec/graphql/query/executor_spec.rb

@@ -189,5 +189,37 @@ describe GraphQL::Query::Executor do
         assert_equal(expected, result)
       end
     end
+
+    describe "for required input object fields" do
+      let(:variables) { {"input" => {} } }
+      let(:query_string) {%| mutation M($input: ReplaceValuesInput!) { replaceValues(input: $input) } |}
+      it "returns a variable validation error" do
+        expected = {
+          "errors"=>[
+            {
+              "message" => "Variable input of type ReplaceValuesInput! was provided invalid value {}",
+              "locations" => [{"line"=>1, "column"=>14}]
+            }
+          ]
+        }
+        assert_equal(expected, result)
+      end
+    end
+
+    describe "for input objects with unknown keys in value" do
+      let(:variables) { {"input" => [{ "foo" => "bar" }]} }
+      let(:query_string) {%| query Q($input: [DairyProductInput]) { searchDairy(product: $input) { __typename, ... on Cheese { id, source } } } |}
+      it "returns a variable validation error" do
+        expected = {
+          "errors"=>[
+            {
+              "message" => "Variable input of type [DairyProductInput] was provided invalid value [{\"foo\":\"bar\"}]",
+              "locations" => [{"line"=>1, "column"=>11}]
+            }
+          ]
+        }
+        assert_equal(expected, result)
+      end
+    end
   end
 end

data/spec/graphql/query_spec.rb

@@ -103,6 +103,7 @@ describe GraphQL::Query do
   describe "merging fragments with different keys" do
     let(:query_string) { %|
       query getCheeseFieldsThroughDairy {
+        ... cheeseFrag3
         dairy {
           ...flavorFragment
           ...fatContentFragment
@@ -124,6 +125,21 @@ describe GraphQL::Query do
           fatContent
         }
       }
+
+      fragment cheeseFrag1 on Query {
+        cheese(id: 1) {
+          id
+        }
+      }
+      fragment cheeseFrag2 on Query {
+        cheese(id: 1) {
+          flavor
+        }
+      }
+      fragment cheeseFrag3 on Query {
+        ... cheeseFrag2
+        ... cheeseFrag1
+      }
     |}
 
     it "should include keys from each fragment" do
@@ -139,7 +155,11 @@ describe GraphQL::Query do
               "fatContent" => 0.04,
             }
           ],
-        }
+        },
+        "cheese" => {
+          "id" => 1,
+          "flavor" => "Brie"
+        },
       }}
       assert_equal(expected, result)
     end
@@ -224,7 +244,7 @@ describe GraphQL::Query do
       let(:query_variables) { {"cheeseId" => "2"} }
 
       it "raises an error" do
-        assert(result["errors"][0]["message"].include?(%{Couldn't coerce "2" to Int}))
+        assert_equal(result["errors"][0]["message"], %{Variable cheeseId of type Int! was provided invalid value "2"})
       end
     end
 

data/spec/graphql/scalar_type_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe GraphQL::ScalarType do
+  let(:scalar) {
+    GraphQL::ScalarType.define do
+      name "BigInt"
+      coerce_input ->(value) { Integer(value) }
+      coerce_result ->(value) { value.to_s }
+    end
+  }
+  let(:bignum) { 2 ** 128 }
+
+  it 'coerces nil into nil' do
+    assert_equal(nil, scalar.coerce_input(nil))
+  end
+
+  it 'coerces input into objects' do
+    assert_equal(bignum, scalar.coerce_input(bignum.to_s))
+  end
+
+  it 'coerces result value for serialization' do
+    assert_equal(bignum.to_s, scalar.coerce_result(bignum))
+  end
+end

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -18,7 +18,7 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
   let(:errors) { validator.validate(document) }
 
   it 'finds undefined arguments to fields and directives' do
-    assert_equal(3, errors.length)
+    assert_equal(4, errors.length)
 
     query_root_error = {
       "message"=>"Argument id on Field 'cheese' has an invalid value",
@@ -26,6 +26,12 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
     }
     assert_includes(errors, query_root_error)
 
+    directive_error = {
+      "message"=>"Argument if on Directive 'skip' has an invalid value",
+      "locations"=>[{"line"=>4, "column"=>31}]
+    }
+    assert_includes(errors, directive_error)
+
     input_object_error = {
       "message"=>"Argument product on Field 'searchDairy' has an invalid value",
       "locations"=>[{"line"=>6, "column"=>7}]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.10.1
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-17 00:00:00.000000000 Z
+date: 2015-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet
@@ -214,7 +214,6 @@ files:
 - lib/graphql/query/directive_chain.rb
 - lib/graphql/query/executor.rb
 - lib/graphql/query/literal_input.rb
-- lib/graphql/query/ruby_input.rb
 - lib/graphql/query/serial_execution.rb
 - lib/graphql/query/serial_execution/field_resolution.rb
 - lib/graphql/query/serial_execution/operation_resolution.rb
@@ -277,12 +276,15 @@ files:
 - spec/graphql/language/parser_spec.rb
 - spec/graphql/language/transform_spec.rb
 - spec/graphql/language/visitor_spec.rb
+- spec/graphql/list_type_spec.rb
 - spec/graphql/object_type_spec.rb
+- spec/graphql/query/arguments_spec.rb
 - spec/graphql/query/base_execution/value_resolution_spec.rb
 - spec/graphql/query/context_spec.rb
 - spec/graphql/query/executor_spec.rb
 - spec/graphql/query/type_resolver_spec.rb
 - spec/graphql/query_spec.rb
+- spec/graphql/scalar_type_spec.rb
 - spec/graphql/schema/field_validator_spec.rb
 - spec/graphql/schema/middleware_chain_spec.rb
 - spec/graphql/schema/printer_spec.rb
@@ -355,12 +357,15 @@ test_files:
 - spec/graphql/language/parser_spec.rb
 - spec/graphql/language/transform_spec.rb
 - spec/graphql/language/visitor_spec.rb
+- spec/graphql/list_type_spec.rb
 - spec/graphql/object_type_spec.rb
+- spec/graphql/query/arguments_spec.rb
 - spec/graphql/query/base_execution/value_resolution_spec.rb
 - spec/graphql/query/context_spec.rb
 - spec/graphql/query/executor_spec.rb
 - spec/graphql/query/type_resolver_spec.rb
 - spec/graphql/query_spec.rb
+- spec/graphql/scalar_type_spec.rb
 - spec/graphql/schema/field_validator_spec.rb
 - spec/graphql/schema/middleware_chain_spec.rb
 - spec/graphql/schema/printer_spec.rb

data/lib/graphql/query/ruby_input.rb

@@ -1,20 +0,0 @@
-module GraphQL
-  class Query
-    # Turn Ruby values into something useful for query execution
-    class RubyInput
-      def initialize(type, incoming_value)
-        @type = type
-        @incoming_value = incoming_value
-      end
-
-      def graphql_value
-        @type.coerce_input!(@incoming_value)
-      end
-
-      def self.coerce(type, value)
-        input = self.new(type, value)
-        input.graphql_value
-      end
-    end
-  end
-end