graphql 0.12.1 → 0.13.0

data/spec/support/star_wars_schema.rb

@@ -1,6 +1,6 @@
 # Based on the graphql-js example
 # https://github.com/graphql/graphql-js/blob/master/src/__tests__/starWarsSchema.js
-require_relative './star_wars_data'
+require_relative "./star_wars_data"
 
 EpisodeEnum = GraphQL::EnumType.define do
   name("Episode")

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 0.12.1
+  version: 0.13.0
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-26 00:00:00.000000000 Z
+date: 2016-04-29 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: parslet
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: codeclimate-test-reporter
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.4'
+- !ruby/object:Gem::Dependency
+  name: guard-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: listen
   requirement: !ruby/object:Gem::Requirement
@@ -150,6 +150,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -199,6 +213,7 @@ files:
 - lib/graphql/interface_type.rb
 - lib/graphql/introspection.rb
 - lib/graphql/introspection/arguments_field.rb
+- lib/graphql/introspection/directive_location_enum.rb
 - lib/graphql/introspection/directive_type.rb
 - lib/graphql/introspection/enum_value_type.rb
 - lib/graphql/introspection/enum_values_field.rb
@@ -218,9 +233,12 @@ files:
 - lib/graphql/introspection/typename_field.rb
 - lib/graphql/invalid_null_error.rb
 - lib/graphql/language.rb
+- lib/graphql/language/lexer.rb
+- lib/graphql/language/lexer.rl
 - lib/graphql/language/nodes.rb
 - lib/graphql/language/parser.rb
-- lib/graphql/language/transform.rb
+- lib/graphql/language/parser.y
+- lib/graphql/language/token.rb
 - lib/graphql/language/visitor.rb
 - lib/graphql/list_type.rb
 - lib/graphql/non_null_type.rb
@@ -228,7 +246,7 @@ files:
 - lib/graphql/query.rb
 - lib/graphql/query/arguments.rb
 - lib/graphql/query/context.rb
-- lib/graphql/query/directive_chain.rb
+- lib/graphql/query/directive_resolution.rb
 - lib/graphql/query/executor.rb
 - lib/graphql/query/input_validation_result.rb
 - lib/graphql/query/literal_input.rb
@@ -241,13 +259,13 @@ files:
 - lib/graphql/query/type_resolver.rb
 - lib/graphql/query/variable_validation_error.rb
 - lib/graphql/query/variables.rb
-- lib/graphql/repl.rb
 - lib/graphql/scalar_type.rb
 - lib/graphql/schema.rb
 - lib/graphql/schema/each_item_validator.rb
 - lib/graphql/schema/field_validator.rb
 - lib/graphql/schema/implementation_validator.rb
 - lib/graphql/schema/middleware_chain.rb
+- lib/graphql/schema/possible_types.rb
 - lib/graphql/schema/printer.rb
 - lib/graphql/schema/rescue_middleware.rb
 - lib/graphql/schema/type_expression.rb
@@ -262,6 +280,7 @@ files:
 - lib/graphql/static_validation/rules/argument_literals_are_compatible.rb
 - lib/graphql/static_validation/rules/arguments_are_defined.rb
 - lib/graphql/static_validation/rules/directives_are_defined.rb
+- lib/graphql/static_validation/rules/directives_are_in_valid_locations.rb
 - lib/graphql/static_validation/rules/document_does_not_exceed_max_depth.rb
 - lib/graphql/static_validation/rules/fields_are_defined_on_type.rb
 - lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb
@@ -302,7 +321,6 @@ files:
 - spec/graphql/introspection/schema_type_spec.rb
 - spec/graphql/introspection/type_type_spec.rb
 - 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
@@ -326,6 +344,7 @@ files:
 - spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb
 - spec/graphql/static_validation/rules/arguments_are_defined_spec.rb
 - spec/graphql/static_validation/rules/directives_are_defined_spec.rb
+- spec/graphql/static_validation/rules/directives_are_in_valid_locations_spec.rb
 - spec/graphql/static_validation/rules/document_does_not_exceed_max_depth_spec.rb
 - spec/graphql/static_validation/rules/fields_are_defined_on_type_spec.rb
 - spec/graphql/static_validation/rules/fields_have_appropriate_selections_spec.rb
@@ -393,7 +412,6 @@ test_files:
 - spec/graphql/introspection/schema_type_spec.rb
 - spec/graphql/introspection/type_type_spec.rb
 - 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
@@ -417,6 +435,7 @@ test_files:
 - spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb
 - spec/graphql/static_validation/rules/arguments_are_defined_spec.rb
 - spec/graphql/static_validation/rules/directives_are_defined_spec.rb
+- spec/graphql/static_validation/rules/directives_are_in_valid_locations_spec.rb
 - spec/graphql/static_validation/rules/document_does_not_exceed_max_depth_spec.rb
 - spec/graphql/static_validation/rules/fields_are_defined_on_type_spec.rb
 - spec/graphql/static_validation/rules/fields_have_appropriate_selections_spec.rb

data/lib/graphql/language/transform.rb

@@ -1,113 +0,0 @@
-module GraphQL
-  module Language
-    # {Transform} is a [parslet](http://kschiess.github.io/parslet/) transform for for turning the AST into objects in {GraphQL::Language::Nodes} objects.
-    class Transform < Parslet::Transform
-
-      # @param [Symbol] name of a node constant
-      # @param [Hash] attributes to initialize the {Node} with
-      # @return [GraphQL::Language::Node] a node of type `name` with attributes `attributes`
-      CREATE_NODE = Proc.new do |name, attributes|
-        node_class = GraphQL::Language::Nodes.const_get(name)
-        node_class.new(attributes)
-      end
-
-      def self.optional_sequence(name)
-        rule(name => simple(:val)) { [] }
-        rule(name => sequence(:val)) { val }
-      end
-
-      # Document
-      rule(document_parts: sequence(:p)) { CREATE_NODE[:Document, definitions: p, line: (p.first ? p.first.line : 1), col: (p.first ? p.first.col : 1)]}
-      rule(document_parts: simple(:p)) { CREATE_NODE[:Document, definitions: [], line: 1, col: 1]}
-
-      # Fragment Definition
-      rule(
-        fragment_keyword: simple(:kw),
-        fragment_name:  simple(:name),
-        type_condition: simple(:type),
-        directives:     sequence(:directives),
-        selections:     sequence(:selections)
-      ) { CREATE_NODE[:FragmentDefinition, name: name.to_s, type: type.to_s, directives: directives, selections: selections, position_source: kw]}
-
-      rule(
-        fragment_spread_keyword: simple(:kw),
-        fragment_spread_name: simple(:n),
-        directives:           sequence(:d)
-      ) { CREATE_NODE[:FragmentSpread, name: n.to_s, directives: d, position_source: kw]}
-
-      rule(
-        fragment_spread_keyword: simple(:kw),
-        inline_fragment_type: simple(:n),
-        directives: sequence(:d),
-        selections: sequence(:s),
-      ) { CREATE_NODE[:InlineFragment, type: n.to_s, directives: d, selections: s, position_source: kw]}
-
-      # Operation Definition
-      rule(
-        operation_type: simple(:ot),
-        name:           simple(:n),
-        variables:      sequence(:v),
-        directives:     sequence(:d),
-        selections:     sequence(:s),
-      ) { CREATE_NODE[:OperationDefinition, operation_type: ot.to_s, name: n.to_s, variables: v, directives: d, selections: s, position_source: ot] }
-      optional_sequence(:optional_variables)
-      rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: simple(:v)) { CREATE_NODE.(:VariableDefinition, name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
-      rule(variable_name: simple(:n), variable_type: simple(:t), variable_optional_default_value: sequence(:v)) { CREATE_NODE.(:VariableDefinition, name: n.name, type: t, default_value: v, line: n.line, col: n.col)}
-      rule(variable_default_value: simple(:v) ) { v }
-      rule(variable_default_value: sequence(:v) ) { v }
-      # Query short-hand
-      rule(unnamed_selections: sequence(:s)) { CREATE_NODE[:OperationDefinition, selections: s, operation_type: "query", name: nil, variables: [], directives: [], line: s.first.line, col: s.first.col]}
-
-      # Field
-      rule(
-        alias: simple(:a),
-        field_name: simple(:name),
-        field_arguments: sequence(:args),
-        directives: sequence(:dir),
-        selections: sequence(:sel)
-      ) { CREATE_NODE[:Field, alias: a && a.to_s, name: name.to_s, arguments: args, directives: dir, selections: sel, position_source: [a, name].find { |part| !part.nil? }] }
-
-      rule(alias_name: simple(:a)) { a }
-      optional_sequence(:optional_field_arguments)
-      rule(field_argument_name: simple(:n), field_argument_value: simple(:v)) { CREATE_NODE[:Argument, name: n.to_s, value: v, position_source: n]}
-      rule(field_argument_name: simple(:n), field_argument_value: subtree(:v)) { CREATE_NODE[:Argument, name: n.to_s, value: v, position_source: n]}
-      optional_sequence(:optional_selections)
-      optional_sequence(:optional_directives)
-
-      # Directive
-      rule(directive_name: simple(:name), directive_arguments: sequence(:args)) { CREATE_NODE[:Directive, name: name.to_s, arguments: args, position_source: name ] }
-      rule(directive_argument_name: simple(:n), directive_argument_value: simple(:v)) { CREATE_NODE[:Argument, name: n.to_s, value: v, position_source: n]}
-      optional_sequence(:optional_directive_arguments)
-
-      # Type Defs
-      rule(type_name: simple(:n))     { CREATE_NODE[:TypeName, name: n.to_s, position_source: n] }
-      rule(list_type: simple(:t))     { CREATE_NODE[:ListType, of_type: t, line: t.line, col: t.col] }
-      rule(non_null_type: simple(:t)) { CREATE_NODE[:NonNullType, of_type: t, line: t.line, col: t.col] }
-
-      # Values
-      rule(array: subtree(:v)) { v }
-      rule(array: simple(:v)) { [] } # just `nil`
-      rule(boolean: simple(:v)) { v == "true" ? true : false }
-      rule(input_object: sequence(:v)) { CREATE_NODE[:InputObject, arguments: v, line: (v.first ? v.first.line : 1), col: (v.first ? v.first.col : 1)] }
-      rule(input_object_name: simple(:n), input_object_value: simple(:v)) { CREATE_NODE[:Argument, name: n.to_s, value: v, position_source: n]}
-      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 }
-
-      ESCAPES = /\\["\\\/bfnrt]/
-      ESCAPES_REPLACE = { '\\"' => '"', "\\\\" => "\\", "\\/" => '/', "\\b" => "\b", "\\f" => "\f", "\\n" => "\n", "\\r" => "\r", "\\t" => "\t" }
-      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, ESCAPES_REPLACE)
-        string.gsub!(UTF_8, &UTF_8_REPLACE)
-        string
-      }
-      rule(optional_string_content: simple(:v)) { v.to_s }
-      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
-  end
-end

data/lib/graphql/query/directive_chain.rb

@@ -1,44 +0,0 @@
-# TODO: directives on fragments: http://facebook.github.io/graphql/#sec-Fragment-Directives
-class GraphQL::Query::DirectiveChain
-  DIRECTIVE_ON = {
-    GraphQL::Language::Nodes::Field =>          GraphQL::Directive::ON_FIELD,
-    GraphQL::Language::Nodes::InlineFragment => GraphQL::Directive::ON_FRAGMENT,
-    GraphQL::Language::Nodes::FragmentSpread => GraphQL::Directive::ON_FRAGMENT,
-  }
-
-  GET_DIRECTIVES = {
-    GraphQL::Language::Nodes::Field =>          Proc.new { |n, f| n.directives },
-    GraphQL::Language::Nodes::InlineFragment => Proc.new { |n, f| n.directives },
-    GraphQL::Language::Nodes::FragmentSpread => Proc.new { |n, f| n.directives + f[n.name].directives }, # get directives from definition too
-  }
-
-  attr_reader :result
-  def initialize(ast_node, query, &block)
-    directives = query.schema.directives
-    on_what = DIRECTIVE_ON[ast_node.class]
-    ast_directives = GET_DIRECTIVES[ast_node.class].call(ast_node, query.fragments)
-
-    if contains_skip?(ast_directives)
-      ast_directives = ast_directives.reject { |ast_directive| ast_directive.name == 'include' }
-    end
-
-    applicable_directives = ast_directives
-      .map { |ast_directive| [ast_directive, directives[ast_directive.name]] }
-      .select { |directive_pair| directive_pair.last.on.include?(on_what) }
-
-    if applicable_directives.none?
-      @result = block.call
-    else
-      applicable_directives.map do |(ast_directive, directive)|
-        args = GraphQL::Query::LiteralInput.from_arguments(ast_directive.arguments, directive.arguments, query.variables)
-        @result = directive.resolve(args, block)
-      end
-      @result ||= {}
-    end
-  end
-
-  private
-  def contains_skip?(directives)
-    directives.any? { |directive| directive.name == 'skip' }
-  end
-end

data/lib/graphql/repl.rb

@@ -1,27 +0,0 @@
-require 'pp'
-class GraphQL::Repl
-  def initialize(schema)
-    @schema = schema
-  end
-
-  def run
-    puts "Starting a repl for schema (type 'quit' to exit)"
-    while line = gets do
-      if line == "quit\n"
-        exit
-      end
-      execute_query(line)
-    end
-  end
-
-  private
-
-  def execute_query(query_string)
-    begin
-      query = GraphQL::Query.new(@schema, query_string)
-      puts JSON.pretty_generate(query.result)
-    rescue StandardError => err
-      puts "Couldn't parse: #{err}\n\n" # #{err.backtrace.join("\n")}"
-    end
-  end
-end

data/spec/graphql/language/transform_spec.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-
-describe GraphQL::Language::Transform do
-  def get_result(query_string, parse: nil, debug: false)
-    # send parse: :value to do something less than a document
-    parser = parse ? GraphQL::PARSER.send(parse) : GraphQL::PARSER
-    raw_tree = parser.parse_with_debug(query_string)
-    transformed_result = GraphQL::TRANSFORM.apply(raw_tree)
-    # send debug: true to see parsing & transforming output
-    if debug
-      p raw_tree.inspect
-      p transformed_result.inspect
-    end
-    transformed_result
-  end
-
-  it 'transforms documents' do
-    query = %|
-      # you can retrieve data:
-      query someInfo($var: [Int!] = [1,2,3]) {
-        me {
-          name, favorite_food,
-          ...personInfo
-          someStuff(vars: [1,2,3])
-          someOtherStuff(input: {ints: [1,2,3]})
-          someEmptyStuff(emptyObj: {}, emptySpaceObj: { })
-          evenMoreStuff(arg: [[1]])
-        }
-      }
-
-      # assign fragments:
-      fragment personInfo on Person {
-        birthdate, name # with fields
-        hobbies(names: [])
-      }
-
-      fragment petInfo on Pet { isHousebroken, species } # all on one line
-
-      # and also mutations
-      mutation changePetInfo($id: Int = 5, $info: [Dog]) {
-        changePetName(id: $id, info: $info) {
-          name,
-          ... petInfo,
-        }
-      }
-    |
-    res = get_result(query, debug: false)
-    assert_equal(4, res.definitions.length)
-
-    res = get_result("{ me {id, birthdate} } # query shorthand")
-    assert_equal(1, res.definitions.length)
-    assert_equal("me", res.definitions.first.selections.first.name)
-  end
-
-  it 'transforms operation definitions' do
-    res = get_result("query someInfo { a, b, c }", parse: :operation_definition)
-    assert_equal("query", res.operation_type)
-    assert_equal("someInfo", res.name)
-    assert_equal(3, res.selections.length)
-
-    res = get_result(
-    "mutation changeThings(
-        $var: Float = 4.5E+6,
-        $arr: [Int]!
-      ) @flag, @skip(if: 1) {
-        changeThings(var: $var) { a,b,c }
-      }", parse: :operation_definition)
-    assert_equal("mutation", res.operation_type)
-    assert_equal("var", res.variables.first.name)
-    assert_equal("Float", res.variables.first.type.name)
-    assert_equal(4_500_000.0, res.variables.first.default_value)
-    assert_equal("arr", res.variables.last.name)
-    assert_equal(3, res.variables.last.line)
-    assert_equal(10, res.variables.last.col)
-    assert_equal("Int", res.variables.last.type.of_type.of_type.name)
-    assert_equal(2, res.directives.length)
-  end
-
-  it 'transforms fragment definitions' do
-    res = get_result("fragment someFields on SomeType @flag1, @flag2 { id, name }", parse: :fragment_definition)
-    assert_equal("someFields", res.name)
-    assert_equal("SomeType", res.type)
-    assert_equal(2, res.directives.length)
-    assert_equal(2, res.selections.length)
-  end
-
-  it 'transforms selections' do
-    res = get_result("{ id, ...petStuff @flag, ... on Pet { isHousebroken }, name }", parse: :selections)
-    expected_classes = [GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::FragmentSpread, GraphQL::Language::Nodes::InlineFragment, GraphQL::Language::Nodes::Field]
-    assert_equal(expected_classes, res.map(&:class))
-  end
-
-  it 'transforms fields' do
-    res = get_result(%|best_pals: friends(first: 3, coolnessLevel: SO_COOL, query: {nice: {very: true}}, emptyStr: "")|, parse: :field)
-    assert_equal(GraphQL::Language::Nodes::Field, res.class)
-    assert_equal(1, res.line)
-    assert_equal(1, res.col)
-    assert_equal("friends", res.name)
-    assert_equal("best_pals", res.alias)
-    assert_equal("first", res.arguments[0].name)
-    assert_equal(3, res.arguments[0].value)
-    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)
-    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(2, res.selections.length)
-  end
-
-  it 'transforms input objects' do
-    res_one_pair    = get_result(%q|{one: 1}|, parse: :value_input_object)
-    res_many_pair   = get_result(%q|{first: "Apple", second: "Banana", third: ORANGE}|, parse: :value_input_object)
-    res_empty       = get_result(%q|{}|, parse: :value_input_object)
-    res_empty_space = get_result(%q|{ }|, parse: :value_input_object)
-
-    assert_equal('one', res_one_pair.arguments[0].name)
-    assert_equal(1    , res_one_pair.arguments[0].value)
-
-    assert_equal("first" , res_many_pair.arguments[0].name)
-    assert_equal("Apple" , res_many_pair.arguments[0].value)
-    assert_equal("second", res_many_pair.arguments[1].name)
-    assert_equal("Banana", res_many_pair.arguments[1].value)
-
-    assert(res_many_pair.arguments[2].value.is_a?(GraphQL::Language::Nodes::Enum))
-    assert_equal("third",  res_many_pair.arguments[2].name)
-    assert_equal("ORANGE", res_many_pair.arguments[2].value.name)
-
-    assert_equal([], res_empty.arguments)
-    assert_equal([], res_empty_space.arguments)
-  end
-
-  it 'transforms directives' do
-    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)
-
-    res = get_result("@someFlag", parse: :directive)
-    assert_equal("someFlag", res.name)
-    assert_equal([], res.arguments, 'gets [] if no args')
-  end
-
-  it 'transforms unnamed operations' do
-    assert_equal(1, get_result("query { me }").definitions.length)
-    assert_equal(1, get_result("mutation { touch }").definitions.length)
-  end
-
-  it 'transforms escaped characters' do
-    res = get_result("{quoted: \"\\\" \\\\ \\/ \\b \\f \\n \\r \\t\"}", parse: :value_input_object)
-    assert_equal("\" \\ / \b \f \n \r \t", res.arguments[0].value)
-  end
-end