graphql 0.9.5 → 0.10.0

data/lib/graphql/language/transform.rb

@@ -1,108 +1,117 @@
-class Parslet::Context
-  def create_node(name, attributes)
-    node_class = GraphQL::Language::Nodes.const_get(name)
-    node_class.new(attributes)
-  end
-end
-
-module GraphQL::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
-    def self.optional_sequence(name)
-      rule(name => simple(:val)) { [] }
-      rule(name => sequence(:val)) { val }
+module GraphQL
+  module Language
+    # Extend `Parslet::Context` with a convenience method
+    # for building AST nodes
+    module ParsletContextCreateNode
+      refine Parslet::Context do
+        # @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`
+        def create_node(name, attributes)
+          node_class = GraphQL::Language::Nodes.const_get(name)
+          node_class.new(attributes)
+        end
+      end
     end
 
+    using ParsletContextCreateNode
 
+    # {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
+      def self.optional_sequence(name)
+        rule(name => simple(:val)) { [] }
+        rule(name => sequence(:val)) { val }
+      end
 
-    # Document
-    rule(document_parts: sequence(:p)) { create_node(:Document, parts: p, line: (p.first ? p.first.line : 1), col: (p.first ? p.first.col : 1))}
-    rule(document_parts: simple(:p)) { create_node(:Document, parts: [], line: 1, col: 1)}
+      # Document
+      rule(document_parts: sequence(:p)) { create_node(:Document, parts: p, line: (p.first ? p.first.line : 1), col: (p.first ? p.first.col : 1))}
+      rule(document_parts: simple(:p)) { create_node(:Document, parts: [], 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)}
+      # 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),
+        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)}
+      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(:Variable, 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(:Variable, 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)}
+      # 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(:Variable, 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(:Variable, 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? }) }
+      # 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: sequence(:v)) { create_node(:Argument, name: n.to_s, value: v, position_source: n)}
-    optional_sequence(:optional_selections)
-    optional_sequence(:optional_directives)
+      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: sequence(: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)
+      # 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)}
+      # 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: sequence(:v)) { v }
-    rule(boolean: simple(:v)) { v == "true" ? true : false }
-    rule(input_object: sequence(:v)) { create_node(:InputObject, pairs: v, line: v.first.line, col: v.first.col) }
-    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 }
+      # Values
+      rule(array: sequence(:v)) { v }
+      rule(boolean: simple(:v)) { v == "true" ? true : false }
+      rule(input_object: sequence(:v)) { create_node(:InputObject, pairs: v, line: v.first.line, col: v.first.col) }
+      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])/
-    UTF_8 = /\\u[\da-f]{4}/i
-    UTF_8_REPLACE = -> (m) { [m[-4..-1].to_i(16)].pack('U') }
+      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)}
+      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
   end
 end

data/lib/graphql/language/visitor.rb

@@ -1,88 +1,92 @@
-# Depth-first traversal through the tree, calling hooks at each stop.
-#
-# @example Create a visitor, add hooks, then search a document
-#   total_field_count = 0
-#   visitor = GraphQL::Language::Visitor.new
-#   # Whenever you find a field, increment the field count:
-#   visitor[GraphQL::Language::Nodes::Field] << -> (node) { total_field_count += 1 }
-#   # When we finish, print the field count:
-#   visitor[GraphQL::Language::Nodes::Document].leave << -> (node) { p total_field_count }
-#   visitor.visit(document)
-#   # => 6
-#
-class GraphQL::Language::Visitor
-  # If any hook returns this value, the {Visitor} stops visiting this
-  # node right away
-  SKIP = :_skip
+module GraphQL
+  module Language
+    # Depth-first traversal through the tree, calling hooks at each stop.
+    #
+    # @example Create a visitor, add hooks, then search a document
+    #   total_field_count = 0
+    #   visitor = GraphQL::Language::Visitor.new
+    #   # Whenever you find a field, increment the field count:
+    #   visitor[GraphQL::Language::Nodes::Field] << -> (node) { total_field_count += 1 }
+    #   # When we finish, print the field count:
+    #   visitor[GraphQL::Language::Nodes::Document].leave << -> (node) { p total_field_count }
+    #   visitor.visit(document)
+    #   # => 6
+    #
+    class Visitor
+      # If any hook returns this value, the {Visitor} stops visiting this
+      # node right away
+      SKIP = :_skip
 
-  # @return [Array<Proc>] Hooks to call when entering _any_ node
-  attr_reader :enter
-  # @return [Array<Proc>] Hooks to call when leaving _any_ node
-  attr_reader :leave
+      # @return [Array<Proc>] Hooks to call when entering _any_ node
+      attr_reader :enter
+      # @return [Array<Proc>] Hooks to call when leaving _any_ node
+      attr_reader :leave
 
-  def initialize
-    @visitors = {}
-    @enter = []
-    @leave = []
-  end
+      def initialize
+        @visitors = {}
+        @enter = []
+        @leave = []
+      end
 
-  # Get a {NodeVisitor} for `node_class`
-  # @param node_class [Class] The node class that you want to listen to
-  # @return [NodeVisitor]
-  #
-  # @example Run a hook whenever you enter a new Field
-  #   visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) { p "Here's a field" }
-  def [](node_class)
-    @visitors[node_class] ||= NodeVisitor.new
-  end
+      # Get a {NodeVisitor} for `node_class`
+      # @param node_class [Class] The node class that you want to listen to
+      # @return [NodeVisitor]
+      #
+      # @example Run a hook whenever you enter a new Field
+      #   visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) { p "Here's a field" }
+      def [](node_class)
+        @visitors[node_class] ||= NodeVisitor.new
+      end
 
-  # Visit `root` and all children, applying hooks as you go
-  # @param root [GraphQL::Language::Nodes::AbstractNode] some node to start parsing on
-  # @return [void]
-  def visit(root, parent=nil)
-    begin_visit(root, parent) &&
-      root.children.reduce(true) { |memo, child| memo && visit(child, root) }
-    end_visit(root, parent)
-  end
+      # Visit `root` and all children, applying hooks as you go
+      # @param root [GraphQL::Language::Nodes::AbstractNode] some node to start parsing on
+      # @return [void]
+      def visit(root, parent=nil)
+        begin_visit(root, parent) &&
+          root.children.reduce(true) { |memo, child| memo && visit(child, root) }
+        end_visit(root, parent)
+      end
 
-  private
+      private
 
-  def begin_visit(node, parent)
-    self.class.apply_hooks(enter, node, parent)
-    node_visitor = self[node.class]
-    self.class.apply_hooks(node_visitor.enter, node, parent)
-  end
+      def begin_visit(node, parent)
+        self.class.apply_hooks(enter, node, parent)
+        node_visitor = self[node.class]
+        self.class.apply_hooks(node_visitor.enter, node, parent)
+      end
 
-  # Should global `leave` visitors come first or last?
-  def end_visit(node, parent)
-    self.class.apply_hooks(leave, node, parent)
-    node_visitor = self[node.class]
-    self.class.apply_hooks(node_visitor.leave, node, parent)
-  end
+      # Should global `leave` visitors come first or last?
+      def end_visit(node, parent)
+        self.class.apply_hooks(leave, node, parent)
+        node_visitor = self[node.class]
+        self.class.apply_hooks(node_visitor.leave, node, parent)
+      end
 
-  # If one of the visitors returns SKIP, stop visiting this node
-  def self.apply_hooks(hooks, node, parent)
-    hooks.reduce(true) { |memo, proc| memo && (proc.call(node, parent) != SKIP) }
-  end
+      # If one of the visitors returns SKIP, stop visiting this node
+      def self.apply_hooks(hooks, node, parent)
+        hooks.reduce(true) { |memo, proc| memo && (proc.call(node, parent) != SKIP) }
+      end
 
-  # Collect `enter` and `leave` hooks for classes in {GraphQL::Language::Nodes}
-  #
-  # Access {NodeVisitor}s via {GraphQL::Language::Visitor#[]}
-  class NodeVisitor
-    # @return [Array<Proc>] Hooks to call when entering a node of this type
-    attr_reader :enter
-    # @return [Array<Proc>] Hooks to call when leaving a node of this type
-    attr_reader :leave
+      # Collect `enter` and `leave` hooks for classes in {GraphQL::Language::Nodes}
+      #
+      # Access {NodeVisitor}s via {GraphQL::Language::Visitor#[]}
+      class NodeVisitor
+        # @return [Array<Proc>] Hooks to call when entering a node of this type
+        attr_reader :enter
+        # @return [Array<Proc>] Hooks to call when leaving a node of this type
+        attr_reader :leave
 
-    def initialize
-      @enter = []
-      @leave = []
-    end
+        def initialize
+          @enter = []
+          @leave = []
+        end
 
-    # Shorthand to add a hook to the {#enter} array
-    # @param hook [Proc] A hook to add
-    def <<(hook)
-      enter << hook
+        # Shorthand to add a hook to the {#enter} array
+        # @param hook [Proc] A hook to add
+        def <<(hook)
+          enter << hook
+        end
+      end
     end
   end
 end

data/lib/graphql/list_type.rb

@@ -16,4 +16,9 @@ class GraphQL::ListType < GraphQL::BaseType
   def to_s
     "[#{of_type.to_s}]"
   end
+
+  def coerce_input(value)
+    inner_type = of_type
+    value.map { |item| inner_type.coerce_input!(item) }
+  end
 end

data/lib/graphql/non_null_type.rb

@@ -13,8 +13,12 @@ class GraphQL::NonNullType < GraphQL::BaseType
     "Non-Null"
   end
 
-  def coerce(value)
-    of_type.coerce(value)
+  def coerce_input(value)
+    of_type.coerce_input(value)
+  end
+
+  def coerce_result(value)
+    of_type.coerce_result(value)
   end
 
   def kind

data/lib/graphql/query.rb

@@ -1,9 +1,23 @@
 class GraphQL::Query
+  class OperationNameMissingError < StandardError
+    def initialize(names)
+      msg = "You must provide an operation name from: #{names.join(", ")}"
+      super(msg)
+    end
+  end
+
+  class VariableMissingError < StandardError
+    def initialize(name, type)
+      msg = "Variable #{name} of type #{type} can't be null"
+      super(msg)
+    end
+  end
+
   # If a resolve function returns `GraphQL::Query::DEFAULT_RESOLVE`,
   # The executor will send the field's name to the target object
   # and use the result.
   DEFAULT_RESOLVE = :__default_resolve
-  attr_reader :schema, :document, :context, :fragments, :variables, :operations, :debug
+  attr_reader :schema, :document, :context, :fragments, :operations, :debug
 
   # Prepare query `query_string` on `schema`
   # @param schema [GraphQL::Schema]
@@ -17,13 +31,11 @@ class GraphQL::Query
     @schema = schema
     @debug = debug
     @context = Context.new(values: context)
-
-    @variables = variables
     @validate = validate
     @operation_name = operation_name
     @fragments = {}
     @operations = {}
-
+    @provided_variables = variables
     @document = GraphQL.parse(query_string)
     @document.parts.each do |part|
       if part.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
@@ -40,20 +52,57 @@ class GraphQL::Query
       return { "errors" => validation_errors }
     end
 
-    @result ||= Executor.new(self, @operation_name).result
+    @result ||= Executor.new(self).result
+  end
+
+
+  # This is the operation to run for this query.
+  # If more than one operation is present, it must be named at runtime.
+  # @return [GraphQL::Language::Nodes::OperationDefinition, nil]
+  def selected_operation
+    @selected_operation ||= find_operation(@operations, @operation_name)
+  end
+
+  # Determine the values for variables of this query, using default values
+  # if a value isn't provided at runtime.
+  #
+  # Raises if a non-null variable isn't provided at runtime.
+  # @return [GraphQL::Query::Variables] Variables to apply to this query
+  def variables
+    @variables ||= GraphQL::Query::Variables.new(
+      schema,
+      selected_operation.variables,
+      @provided_variables
+    )
   end
 
   private
 
   def validation_errors
-    @validation_errors ||= @schema.static_validator.validate(@document)
+    @validation_errors ||= schema.static_validator.validate(document)
+  end
+
+
+  def find_operation(operations, operation_name)
+    if operations.length == 1
+      operations.values.first
+    elsif operations.length == 0
+      nil
+    elsif !operations.key?(operation_name)
+      raise OperationNameMissingError, operations.keys
+    else
+      operations[operation_name]
+    end
   end
 end
 
 require 'graphql/query/arguments'
 require 'graphql/query/base_execution'
-require 'graphql/query/serial_execution'
-require 'graphql/query/type_resolver'
+require 'graphql/query/context'
 require 'graphql/query/directive_chain'
 require 'graphql/query/executor'
-require 'graphql/query/context'
+require 'graphql/query/literal_input'
+require 'graphql/query/ruby_input'
+require 'graphql/query/serial_execution'
+require 'graphql/query/type_resolver'
+require 'graphql/query/variables'