graphql 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c92fe281f2beeab6fd1e4c6165f07c5156ccb09a
-  data.tar.gz: 309513164d1b60381f7283592fb3f83f4105fb9b
+  metadata.gz: 16c0fb0de67cb50d74c16528abcccb26ad91b01f
+  data.tar.gz: 008d40ba5dca1c8fb2c8800f987f02981c64d6f9
 SHA512:
-  metadata.gz: 0a7345b8975ac69de12cae806c9b0f72bb9ada248a6fedf0f948113573676c4c938b090ff37b8f7b4cc5a3bcc661aadb5239700a832ab5ad9746d911f69cf198
-  data.tar.gz: dc45fdc6b9670f353fa37be7fe1a019d39874f78f89e33ec971dc61119e40e88a4837092bb1ecaa6861623c53c18e750a39d19006a8c5bc15edf1c2f5d18e47f
+  metadata.gz: 2573ce8d132b479472db3a680861289e996ad213c6173ad1fadac0ed3377219a7cc41cf7089149b60e81b2dc75fe5c50a38fc6af51e201744b129fc2bf934019
+  data.tar.gz: 79877bafa23685bedf218e78f9572a1795a30383433943586842ba7605696a71eb391fcf429cc66f6992a9ff29121fff6086d9b428d925541a0f655ef20c90f5

data/lib/graphql/language/parser.rb

@@ -95,8 +95,17 @@ module GraphQL::Language
     rule(:value_input_object) { str("{") >> value_input_object_pair.repeat(1).as(:input_object) >> str("}") }
     rule(:value_input_object_pair) { space? >> name.as(:input_object_name) >>  space? >> str(":") >> space? >> value.as(:input_object_value) >> separator? }
     rule(:value_int) { (value_sign? >> match('\d').repeat(1)).as(:int) }
-    # TODO: support unicode, escaped chars (match the spec)
-    rule(:value_string) { str('"') >> match('[^\"]').repeat(1).as(:string) >> str('"')}
+    rule(:value_string) { str('"') >> value_string_char.repeat.as(:string) >> str('"')}
+    rule(:value_string_char) { value_string_escaped_char | value_string_escaped_unicode | value_string_source_char}
+    rule(:value_string_escaped_char) { str("\\") >> match('["\/bfnrt]') }
+    rule(:value_string_escaped_unicode) { str("\\") >> match('u[\dA-Fa-f]{4}')}
+    rule(:value_string_source_char) { (str('"') | str("\\") | value_string_line_terminator).absent? >> any }
+    rule(:value_string_line_terminator) {
+      str('\u000A') | # new line
+      str('\u000D') | # carriage return
+      str('\u2028') | # line separator
+      str('\u2029')   # paragraph separator
+    }
     rule(:value_enum) { name.as(:enum) }
     rule(:value_variable) { str("$") >> name.as(:variable) }
 

data/lib/graphql/language/transform.rb

@@ -91,7 +91,17 @@ module GraphQL::Language
     rule(input_object_name: simple(:n), input_object_value: sequence(:v)) { create_node(:Argument, name: n.to_s, value: v, position_source: n)}
     rule(int: simple(:v)) { v.to_i }
     rule(float: simple(:v)) { v.to_f }
-    rule(string: simple(:v)) { v.to_s }
+
+    ESCAPES = /\\(["\\\/bfnrt])/
+    UTF_8 = /\\u[\da-f]{4}/i
+    UTF_8_REPLACE = -> (m) { [m[-4..-1].to_i(16)].pack('U') }
+
+    rule(string: simple(:v)) {
+      string = v.to_s
+      string.gsub!(ESCAPES, '\1')
+      string.gsub!(UTF_8, &UTF_8_REPLACE)
+      string
+    }
     rule(variable: simple(:v)) { create_node(:VariableIdentifier, name: v.to_s, position_source: v) }
     rule(enum: simple(:v)) { create_node(:Enum, name: v.to_s, position_source: v)}
   end

data/lib/graphql/query/arguments.rb

@@ -13,7 +13,7 @@ class GraphQL::Query::Arguments
     end
   end
 
-  def_delegators :@hash, :keys, :values
+  def_delegators :@hash, :keys, :values, :inspect, :to_h
 
   def [](key)
     @hash[key.to_s]

data/lib/graphql/schema/each_item_validator.rb

@@ -4,9 +4,14 @@ class GraphQL::Schema::EachItemValidator
   end
 
   def validate(items, as:, must_be:)
-    invalid_items = items.select {|k| !yield(k) }
-    if invalid_items.any?
-      @errors << "#{as} must be #{must_be}, but some aren't: #{invalid_items.map(&:to_s).join(", ")}"
+    if !items.is_a?(Array)
+      @errors << "#{as} must be an Array, not #{items.inspect}"
+      return
+    else
+      invalid_items = items.select {|k| !yield(k) }
+      if invalid_items.any?
+        @errors << "#{as} must be #{must_be}, but some aren't: #{invalid_items.map(&:to_s).join(", ")}"
+      end
     end
   end
 end

data/lib/graphql/schema/implementation_validator.rb

@@ -11,11 +11,17 @@ class GraphQL::Schema::ImplementationValidator
   # If `block_given?`, yield the return value of that method
   # If provided, use `as` in the error message, overriding class-level `as`.
   def must_respond_to(method_name, args: [], as: nil)
+    local_as = as || implementation_as
+    method_signature = "##{method_name}(#{args.join(", ")})"
     if !object.respond_to?(method_name)
-      local_as = as || implementation_as
-      errors << "#{object.to_s} must respond to ##{method_name}(#{args.join(", ")}) to be a #{local_as}"
+      errors << "#{object.to_s} must respond to #{method_signature} to be a #{local_as}"
     elsif block_given?
-      yield(object.public_send(method_name))
+      return_value = object.public_send(method_name)
+      if return_value.nil?
+        errors << "#{object.to_s} must return a value for #{method_signature} to be a #{local_as}"
+      else
+        yield(return_value)
+      end
     end
   end
 end

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

@@ -30,8 +30,17 @@ class GraphQL::StaticValidation::VariableUsagesAreAllowed
     end
 
     arg_defn = arguments[arg_node.name]
-    if var_type != arg_defn.type
-      context.errors << message("Type mismatch on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node)
+    arg_defn_type = arg_defn.type
+
+    var_inner_type = var_type.kind.unwrap(var_type)
+    arg_inner_type = arg_defn_type.kind.unwrap(arg_defn_type)
+
+    if var_inner_type != arg_inner_type
+      context.errors << create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node)
+    elsif list_dimension(var_type) != list_dimension(arg_defn_type)
+      context.errors << create_error("List dimension mismatch", var_type, ast_var, arg_defn, arg_node)
+    elsif !non_null_levels_match(arg_defn_type, var_type)
+      context.errors << create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node)
     end
   end
 
@@ -44,4 +53,28 @@ class GraphQL::StaticValidation::VariableUsagesAreAllowed
       types[ast_type.name]
     end
   end
+
+  def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
+    message("#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node)
+  end
+
+  def list_dimension(type)
+    if type.kind.list?
+      1 + list_dimension(type.of_type)
+    elsif type.kind.non_null?
+      list_dimension(type.of_type)
+    else
+      0
+    end
+  end
+
+  def non_null_levels_match(arg_type, var_type)
+    if arg_type.kind.non_null? && !var_type.kind.non_null?
+      false
+    elsif arg_type.kind.wraps? && var_type.kind.wraps?
+      non_null_levels_match(arg_type.of_type, var_type.of_type)
+    else
+      true
+    end
+  end
 end

data/lib/graphql/version.rb

@@ -1,3 +1,3 @@
 module GraphQL
-  VERSION = "0.6.0"
+  VERSION = "0.6.1"
 end

data/spec/graphql/language/parser_spec.rb

@@ -59,7 +59,7 @@ describe GraphQL::Language::Parser do
 
   it 'parses directives' do
     assert(parser.directives.parse_with_debug("@doSomething"), 'gets without argument')
-    assert(parser.directives.parse_with_debug('@doSomething(why: "forSomeReason")'), 'gets with argument')
+    assert(parser.directives.parse_with_debug('@doSomething(why: "\"forSomeReason\"")'), 'gets with argument')
     assert(parser.directives.parse_with_debug('@myFlag, @doSomething(why: "forSomeReason")'), 'gets multiple')
   end
 
@@ -67,7 +67,7 @@ describe GraphQL::Language::Parser do
     assert(parser.field.parse_with_debug(%|myField { name, id }|), 'gets subselections')
     assert(parser.field.parse_with_debug(%{myAlias: myField}), 'gets an alias')
     assert(parser.field.parse_with_debug(%{myField(intKey: 1, floatKey: 1.1e5)}), 'gets arguments')
-    assert(parser.field.parse_with_debug(%{myAlias: myField(stringKey: "my_string", boolKey: false, objKey: {key : true})}), 'gets alias and arguments')
+    assert(parser.field.parse_with_debug('myAlias: myField(stringKey: "\"my_string\"", boolKey: false, objKey: {key : true})'), 'gets alias and arguments')
     assert(parser.field.parse_with_debug(%|myField @withFlag, @skip(if: true) { name, id }|), 'gets with directive')
   end
 
@@ -100,7 +100,10 @@ describe GraphQL::Language::Parser do
     end
 
     it 'gets strings' do
-      assert(parser.value.parse_with_debug('"my string"'))
+      assert(parser.value.parse_with_debug('"my string"'), "plain strings")
+      assert(parser.value.parse_with_debug('""'), "empty strings")
+      assert(parser.value.parse_with_debug('"\"Hi!\"\n"'), "escaped strings")
+      assert(parser.value.parse_with_debug('"\u0025\u0026"'), "escaped unicode")
     end
 
     it 'gets arrays' do

data/spec/graphql/language/transform_spec.rb

@@ -99,20 +99,20 @@ describe GraphQL::Language::Transform do
     assert_equal("SO_COOL", res.arguments[1].value.name)
     assert_equal({"nice" => {"very" => true}}, res.arguments[2].value.to_h)
 
-    res = get_result(%|me @flag, @include(if: "something") {name, id}|, parse: :field)
+    res = get_result('me @flag, @include(if: "\"something\"") {name, id}', parse: :field)
     assert_equal("me", res.name)
     assert_equal(nil, res.alias)
     assert_equal(2, res.directives.length)
     assert_equal("flag", res.directives.first.name)
-    assert_equal("something", res.directives.last.arguments.first.value)
+    assert_equal('"something"', res.directives.last.arguments.first.value)
     assert_equal(2, res.selections.length)
   end
 
   it 'transforms directives' do
-    res = get_result("@doSomething(vigorously: true)", parse: :directive)
+    res = get_result('@doSomething(vigorously: "\"true\u0025\"")', parse: :directive)
     assert_equal("doSomething", res.name, 'gets the name without @')
     assert_equal("vigorously", res.arguments.first.name)
-    assert_equal(true, res.arguments.first.value)
+    assert_equal('"true%"', res.arguments.first.value)
 
     res = get_result("@someFlag", parse: :directive)
     assert_equal("someFlag", res.name)

data/spec/graphql/schema/type_validator_spec.rb

@@ -28,6 +28,16 @@ describe GraphQL::Schema::TypeValidator do
     end
   end
 
+  describe 'when a method returns nil' do
+    let(:type_defn) { base_type_defn.merge(interfaces: nil)}
+    it 'requires name' do
+      assert_equal(
+        ["InvalidType must return a value for #interfaces() to be a OBJECT"],
+        errors
+      )
+    end
+  end
+
   describe "when a field name isnt a string" do
     let(:type_defn) { base_type_defn.merge(fields: {symbol_field: (GraphQL::Field.new {|f|}) }) }
     it "requires string names" do

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

@@ -9,6 +9,7 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
         $badStr: String!,
         $goodAnimals: [DairyAnimal!]!,
         $badAnimals: [DairyAnimal]!,
+        $deepAnimals: [[DairyAnimal!]!]!,
     ) {
       goodCheese:   cheese(id: $goodInt)  { source }
       okCheese:     cheese(id: $okInt)    { source }
@@ -17,6 +18,11 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
       cheese(id: 1) {
         similarCheeses(source: $goodAnimals)
         other: similarCheeses(source: $badAnimals)
+        tooDeep: similarCheeses(source: $deepAnimals)
+      }
+
+      milk(id: 1) {
+        flavors(limit: $okInt)
       }
     }
   ')}
@@ -25,19 +31,23 @@ describe GraphQL::StaticValidation::VariableUsagesAreAllowed do
   let(:errors) { validator.validate(document) }
 
   it "finds variables used as arguments but don't match the argument's type" do
-    assert_equal(3, errors.length)
+    assert_equal(4, errors.length)
     expected = [
       {
-        "message"=>"Type mismatch on variable $badInt and argument id (Int / Int!)",
-        "locations"=>[{"line"=>12, "column"=>28}]
+        "message"=>"Nullability mismatch on variable $badInt and argument id (Int / Int!)",
+        "locations"=>[{"line"=>13, "column"=>28}]
       },
       {
         "message"=>"Type mismatch on variable $badStr and argument id (String! / Int!)",
-        "locations"=>[{"line"=>13, "column"=>28}]
+        "locations"=>[{"line"=>14, "column"=>28}]
+      },
+      {
+        "message"=>"Nullability mismatch on variable $badAnimals and argument source ([DairyAnimal]! / [DairyAnimal!]!)",
+        "locations"=>[{"line"=>17, "column"=>31}]
       },
       {
-        "message"=>"Type mismatch on variable $badAnimals and argument source ([DairyAnimal]! / [DairyAnimal!]!)",
-        "locations"=>[{"line"=>16, "column"=>31}]
+        "message"=>"List dimension mismatch on variable $deepAnimals and argument source ([[DairyAnimal!]!]! / [DairyAnimal!]!)",
+        "locations"=>[{"line"=>18, "column"=>33}]
       }
     ]
     assert_equal(expected, errors)

data/spec/support/dairy_app.rb

@@ -140,8 +140,6 @@ ReplaceValuesInputType = GraphQL::InputObjectType.define do
   input_field :values, !types[!types.Int]
 end
 
-p ReplaceValuesInputType.input_fields.inspect
-
 MutationType = GraphQL::ObjectType.define do
   name "Mutation"
   description "The root for mutations in this schema"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-14 00:00:00.000000000 Z
+date: 2015-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parslet