graphql 0.12.1 → 0.13.0

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

@@ -1,27 +1,31 @@
-class GraphQL::StaticValidation::VariablesAreInputTypes
-  include GraphQL::StaticValidation::Message::MessageHelper
+module GraphQL
+  module StaticValidation
+    class VariablesAreInputTypes
+      include GraphQL::StaticValidation::Message::MessageHelper
 
-  def validate(context)
-    context.visitor[GraphQL::Language::Nodes::VariableDefinition] << -> (node, parent) {
-      validate_is_input_type(node, context)
-    }
-  end
+      def validate(context)
+        context.visitor[GraphQL::Language::Nodes::VariableDefinition] << -> (node, parent) {
+          validate_is_input_type(node, context)
+        }
+      end
 
-  private
+      private
 
-  def validate_is_input_type(node, context)
-    type_name = get_type_name(node.type)
-    type = context.schema.types[type_name]
-    if !type.kind.input?
-      context.errors << message("#{type.name} isn't a valid input type (on $#{node.name})", node)
-    end
-  end
+      def validate_is_input_type(node, context)
+        type_name = get_type_name(node.type)
+        type = context.schema.types[type_name]
+        if !type.kind.input?
+          context.errors << message("#{type.name} isn't a valid input type (on $#{node.name})", node)
+        end
+      end
 
-  def get_type_name(ast_type)
-    if ast_type.respond_to?(:of_type)
-      get_type_name(ast_type.of_type)
-    else
-      ast_type.name
+      def get_type_name(ast_type)
+        if ast_type.respond_to?(:of_type)
+          get_type_name(ast_type.of_type)
+        else
+          ast_type.name
+        end
+      end
     end
   end
 end

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

@@ -1,130 +1,133 @@
-# The problem is
-#   - Variable usage must be determined at the OperationDefinition level
-#   - You can't tell how fragments use variables until you visit FragmentDefinitions (which may be at the end of the document)
-#
-#  So, this validator includes some crazy logic to follow fragment spreads recursively, while avoiding infinite loops.
-#
-# `graphql-js` solves this problem by:
-#   - re-visiting the AST for each validator
-#   - allowing validators to say `followSpreads: true`
-#
-class GraphQL::StaticValidation::VariablesAreUsedAndDefined
-  include GraphQL::StaticValidation::Message::MessageHelper
-
-  class VariableUsage
-    attr_accessor :ast_node, :used_by, :declared_by
-    def used?
-      !!@used_by
-    end
+module GraphQL
+  module StaticValidation
+    # The problem is
+    #   - Variable usage must be determined at the OperationDefinition level
+    #   - You can't tell how fragments use variables until you visit FragmentDefinitions (which may be at the end of the document)
+    #
+    #  So, this validator includes some crazy logic to follow fragment spreads recursively, while avoiding infinite loops.
+    #
+    # `graphql-js` solves this problem by:
+    #   - re-visiting the AST for each validator
+    #   - allowing validators to say `followSpreads: true`
+    #
+    class VariablesAreUsedAndDefined
+      include GraphQL::StaticValidation::Message::MessageHelper
+
+      class VariableUsage
+        attr_accessor :ast_node, :used_by, :declared_by
+        def used?
+          !!@used_by
+        end
 
-    def declared?
-      !!@declared_by
-    end
-  end
+        def declared?
+          !!@declared_by
+        end
+      end
 
-  def variable_hash
-    Hash.new {|h, k| h[k] = VariableUsage.new }
-  end
+      def variable_hash
+        Hash.new {|h, k| h[k] = VariableUsage.new }
+      end
 
-  def validate(context)
-    variable_usages_for_context = Hash.new {|hash, key| hash[key] = variable_hash }
-    spreads_for_context = Hash.new {|hash, key| hash[key] = [] }
-    variable_context_stack = []
-
-    # OperationDefinitions and FragmentDefinitions
-    # both push themselves onto the context stack (and pop themselves off)
-    push_variable_context_stack = -> (node, parent) {
-      # initialize the hash of vars for this context:
-      variable_usages_for_context[node]
-      variable_context_stack.push(node)
-    }
-
-    pop_variable_context_stack = -> (node, parent) {
-      variable_context_stack.pop
-    }
-
-
-    context.visitor[GraphQL::Language::Nodes::OperationDefinition] << push_variable_context_stack
-    context.visitor[GraphQL::Language::Nodes::OperationDefinition] << -> (node, parent) {
-      # mark variables as defined:
-      var_hash = variable_usages_for_context[node]
-      node.variables.each { |var| var_hash[var.name].declared_by = node }
-    }
-    context.visitor[GraphQL::Language::Nodes::OperationDefinition].leave << pop_variable_context_stack
-
-    context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << push_variable_context_stack
-    context.visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << pop_variable_context_stack
-
-    # For FragmentSpreads:
-    #  - find the context on the stack
-    #  - mark the context as containing this spread
-    context.visitor[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
-      variable_context = variable_context_stack.last
-      spreads_for_context[variable_context] << node.name
-    }
-
-    # For VariableIdentifiers:
-    #  - mark the variable as used
-    #  - assign its AST node
-    context.visitor[GraphQL::Language::Nodes::VariableIdentifier] << -> (node, parent) {
-      usage_context = variable_context_stack.last
-      declared_variables = variable_usages_for_context[usage_context]
-      usage = declared_variables[node.name]
-      usage.used_by = usage_context
-      usage.ast_node = node
-    }
-
-
-    context.visitor[GraphQL::Language::Nodes::Document].leave << -> (node, parent) {
-      fragment_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
-      operation_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
-
-      operation_definitions.each do |node, node_variables|
-        follow_spreads(node, node_variables, spreads_for_context, fragment_definitions, [])
-        create_errors(node_variables, context)
+      def validate(context)
+        variable_usages_for_context = Hash.new {|hash, key| hash[key] = variable_hash }
+        spreads_for_context = Hash.new {|hash, key| hash[key] = [] }
+        variable_context_stack = []
+
+        # OperationDefinitions and FragmentDefinitions
+        # both push themselves onto the context stack (and pop themselves off)
+        push_variable_context_stack = -> (node, parent) {
+          # initialize the hash of vars for this context:
+          variable_usages_for_context[node]
+          variable_context_stack.push(node)
+        }
+
+        pop_variable_context_stack = -> (node, parent) {
+          variable_context_stack.pop
+        }
+
+
+        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << push_variable_context_stack
+        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << -> (node, parent) {
+          # mark variables as defined:
+          var_hash = variable_usages_for_context[node]
+          node.variables.each { |var| var_hash[var.name].declared_by = node }
+        }
+        context.visitor[GraphQL::Language::Nodes::OperationDefinition].leave << pop_variable_context_stack
+
+        context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << push_variable_context_stack
+        context.visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << pop_variable_context_stack
+
+        # For FragmentSpreads:
+        #  - find the context on the stack
+        #  - mark the context as containing this spread
+        context.visitor[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
+          variable_context = variable_context_stack.last
+          spreads_for_context[variable_context] << node.name
+        }
+
+        # For VariableIdentifiers:
+        #  - mark the variable as used
+        #  - assign its AST node
+        context.visitor[GraphQL::Language::Nodes::VariableIdentifier] << -> (node, parent) {
+          usage_context = variable_context_stack.last
+          declared_variables = variable_usages_for_context[usage_context]
+          usage = declared_variables[node.name]
+          usage.used_by = usage_context
+          usage.ast_node = node
+        }
+
+
+        context.visitor[GraphQL::Language::Nodes::Document].leave << -> (node, parent) {
+          fragment_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
+          operation_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
+
+          operation_definitions.each do |node, node_variables|
+            follow_spreads(node, node_variables, spreads_for_context, fragment_definitions, [])
+            create_errors(node_variables, context)
+          end
+        }
       end
-    }
-  end
 
-  private
-
-  # Follow spreads in `node`, looking them up from `spreads_for_context` and finding their match in `fragment_definitions`.
-  # Use those fragments to update {VariableUsage}s in `parent_variables`.
-  # Avoid infinite loops by skipping anything in `visited_fragments`.
-  def follow_spreads(node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
-    spreads = spreads_for_context[node] - visited_fragments
-    spreads.each do |spread_name|
-      def_node, variables = fragment_definitions.find { |def_node, vars| def_node.name == spread_name }
-      next if !def_node
-      visited_fragments << spread_name
-      variables.each do |name, child_usage|
-        parent_usage = parent_variables[name]
-        if child_usage.used?
-          parent_usage.ast_node   = child_usage.ast_node
-          parent_usage.used_by    = child_usage.used_by
+      private
+
+      # Follow spreads in `node`, looking them up from `spreads_for_context` and finding their match in `fragment_definitions`.
+      # Use those fragments to update {VariableUsage}s in `parent_variables`.
+      # Avoid infinite loops by skipping anything in `visited_fragments`.
+      def follow_spreads(node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
+        spreads = spreads_for_context[node] - visited_fragments
+        spreads.each do |spread_name|
+          def_node, variables = fragment_definitions.find { |def_node, vars| def_node.name == spread_name }
+          next if !def_node
+          visited_fragments << spread_name
+          variables.each do |name, child_usage|
+            parent_usage = parent_variables[name]
+            if child_usage.used?
+              parent_usage.ast_node   = child_usage.ast_node
+              parent_usage.used_by    = child_usage.used_by
+            end
+          end
+          follow_spreads(def_node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
         end
       end
-      follow_spreads(def_node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
-    end
-  end
 
-  # Determine all the error messages,
-  # Then push messages into the validation context
-  def create_errors(node_variables, context)
-    errors = []
-    # Declared but not used:
-    errors += node_variables
-      .select { |name, usage| usage.declared? && !usage.used? }
-      .map { |var_name, usage| ["Variable $#{var_name} is declared by #{usage.declared_by.name} but not used", usage.declared_by] }
-
-    # Used but not declared:
-    errors += node_variables
-      .select { |name, usage| usage.used? && !usage.declared? }
-      .map { |var_name, usage| ["Variable $#{var_name} is used by #{usage.used_by.name} but not declared", usage.ast_node] }
-
-    errors.each do |error_args|
-      context.errors << message(*error_args)
+      # Determine all the error messages,
+      # Then push messages into the validation context
+      def create_errors(node_variables, context)
+        errors = []
+        # Declared but not used:
+        errors += node_variables
+          .select { |name, usage| usage.declared? && !usage.used? }
+          .map { |var_name, usage| ["Variable $#{var_name} is declared by #{usage.declared_by.name} but not used", usage.declared_by] }
+
+        # Used but not declared:
+        errors += node_variables
+          .select { |name, usage| usage.used? && !usage.declared? }
+          .map { |var_name, usage| ["Variable $#{var_name} is used by #{usage.used_by.name} but not declared", usage.ast_node] }
+
+        errors.each do |error_args|
+          context.errors << message(*error_args)
+        end
+      end
     end
   end
-
 end

data/lib/graphql/static_validation/type_stack.rb

@@ -1,150 +1,159 @@
-# - Ride along with `GraphQL::Language::Visitor`
-# - Track type info, expose it to validators
-class GraphQL::StaticValidation::TypeStack
-  # These are jumping-off points for infering types down the tree
-  TYPE_INFERRENCE_ROOTS = [
-    GraphQL::Language::Nodes::OperationDefinition,
-    GraphQL::Language::Nodes::FragmentDefinition,
-  ]
-
-  # @return [GraphQL::Schema] the schema whose types are present in this document
-  attr_reader :schema
-
-  # When it enters an object (starting with query or mutation root), it's pushed on this stack.
-  # When it exits, it's popped off.
-  # @return [Array<GraphQL::ObjectType, GraphQL::Union, GraphQL::Interface>]
-  attr_reader :object_types
-
-  # When it enters a field, it's pushed on this stack (useful for nested fields, args).
-  # When it exits, it's popped off.
-  # @return [Array<GraphQL::Field>] fields which have been entered
-  attr_reader :field_definitions
-
-  # Directives are pushed on, then popped off while traversing the tree
-  # @return [Array<GraphQL::Node::Directive>] directives which have been entered
-  attr_reader :directive_definitions
-
-  # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
-  attr_reader :argument_definitions
-
-  # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
-  # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
-  def initialize(schema, visitor)
-    @schema = schema
-    @object_types = []
-    @field_definitions = []
-    @directive_definitions = []
-    @argument_definitions = []
-    visitor.enter << -> (node, parent) { PUSH_STRATEGIES[node.class].push(self, node) }
-    visitor.leave << -> (node, parent) { PUSH_STRATEGIES[node.class].pop(self, node) }
-  end
+module GraphQL
+  module StaticValidation
+    # - Ride along with `GraphQL::Language::Visitor`
+    # - Track type info, expose it to validators
+    class TypeStack
+      # These are jumping-off points for infering types down the tree
+      TYPE_INFERRENCE_ROOTS = [
+        GraphQL::Language::Nodes::OperationDefinition,
+        GraphQL::Language::Nodes::FragmentDefinition,
+      ]
+
+      # @return [GraphQL::Schema] the schema whose types are present in this document
+      attr_reader :schema
+
+      # When it enters an object (starting with query or mutation root), it's pushed on this stack.
+      # When it exits, it's popped off.
+      # @return [Array<GraphQL::ObjectType, GraphQL::Union, GraphQL::Interface>]
+      attr_reader :object_types
+
+      # When it enters a field, it's pushed on this stack (useful for nested fields, args).
+      # When it exits, it's popped off.
+      # @return [Array<GraphQL::Field>] fields which have been entered
+      attr_reader :field_definitions
+
+      # Directives are pushed on, then popped off while traversing the tree
+      # @return [Array<GraphQL::Node::Directive>] directives which have been entered
+      attr_reader :directive_definitions
+
+      # @return [Array<GraphQL::Node::Argument>] arguments which have been entered
+      attr_reader :argument_definitions
+
+      # @param schema [GraphQL::Schema] the schema whose types to use when climbing this document
+      # @param visitor [GraphQL::Language::Visitor] a visitor to follow & watch the types
+      def initialize(schema, visitor)
+        @schema = schema
+        @object_types = []
+        @field_definitions = []
+        @directive_definitions = []
+        @argument_definitions = []
+        visitor.enter << -> (node, parent) { PUSH_STRATEGIES[node.class].push(self, node) }
+        visitor.leave << -> (node, parent) { PUSH_STRATEGIES[node.class].pop(self, node) }
+      end
 
-  private
+      private
 
-  # Look up strategies by name and use singleton instance to push and pop
-  PUSH_STRATEGIES = Hash.new { |hash, key| hash[key] = get_strategy_for_node_class(key) }
+      # Look up strategies by name and use singleton instance to push and pop
+      PUSH_STRATEGIES = Hash.new { |hash, key| hash[key] = get_strategy_for_node_class(key) }
 
-  def self.get_strategy_for_node_class(node_class)
-    node_class_name = node_class.name.split("::").last
-    strategy_key = "#{node_class_name}Strategy"
-    const_defined?(strategy_key) ? const_get(strategy_key).new : NullStrategy.new
-  end
+      def self.get_strategy_for_node_class(node_class)
+        node_class_name = node_class.name.split("::").last
+        strategy_key = "#{node_class_name}Strategy"
+        const_defined?(strategy_key) ? const_get(strategy_key).new : NullStrategy.new
+      end
 
-  class FragmentWithTypeStrategy
-    def push(stack, node)
-      object_type = stack.schema.types.fetch(node.type, nil)
-      if !object_type.nil?
-        object_type = object_type.unwrap
+      class FragmentWithTypeStrategy
+        def push(stack, node)
+          object_type = if node.type
+            stack.schema.types.fetch(node.type, nil)
+          else
+            stack.object_types.last
+          end
+          if !object_type.nil?
+            object_type = object_type.unwrap
+          end
+          stack.object_types.push(object_type)
+        end
+
+        def pop(stack, node)
+          stack.object_types.pop
+        end
       end
-      stack.object_types.push(object_type)
-    end
 
-    def pop(stack, node)
-      stack.object_types.pop
-    end
-  end
+      class FragmentDefinitionStrategy < FragmentWithTypeStrategy; end
+      class InlineFragmentStrategy < FragmentWithTypeStrategy; end
 
-  class FragmentDefinitionStrategy < FragmentWithTypeStrategy; end
-  class InlineFragmentStrategy < FragmentWithTypeStrategy; end
+      class OperationDefinitionStrategy
+        def push(stack, node)
+          # eg, QueryType, MutationType
+          object_type = stack.schema.public_send(node.operation_type)
+          stack.object_types.push(object_type)
+        end
 
-  class OperationDefinitionStrategy
-    def push(stack, node)
-      # eg, QueryType, MutationType
-      object_type = stack.schema.public_send(node.operation_type)
-      stack.object_types.push(object_type)
-    end
-    def pop(stack, node)
-      stack.object_types.pop
-    end
-  end
+        def pop(stack, node)
+          stack.object_types.pop
+        end
+      end
 
-  class FieldStrategy
-    def push(stack, node)
-      parent_type = stack.object_types.last
-      parent_type = parent_type.unwrap
-      if parent_type.kind.fields?
-        field_class = stack.schema.get_field(parent_type, node.name)
-        stack.field_definitions.push(field_class)
-        if !field_class.nil?
-          next_object_type = field_class.type
-          stack.object_types.push(next_object_type)
-        else
-          stack.object_types.push(nil)
+      class FieldStrategy
+        def push(stack, node)
+          parent_type = stack.object_types.last
+          parent_type = parent_type.unwrap
+          if parent_type.kind.fields?
+            field_class = stack.schema.get_field(parent_type, node.name)
+            stack.field_definitions.push(field_class)
+            if !field_class.nil?
+              next_object_type = field_class.type
+              stack.object_types.push(next_object_type)
+            else
+              stack.object_types.push(nil)
+            end
+          else
+            stack.field_definitions.push(nil)
+            stack.object_types.push(parent_type)
+          end
+        end
+
+        def pop(stack, node)
+          stack.field_definitions.pop
+          stack.object_types.pop
         end
-      else
-        stack.field_definitions.push(nil)
-        stack.object_types.push(parent_type)
       end
-    end
 
-    def pop(stack, node)
-      stack.field_definitions.pop
-      stack.object_types.pop
-    end
-  end
+      class DirectiveStrategy
+        def push(stack, node)
+          directive_defn = stack.schema.directives[node.name]
+          stack.directive_definitions.push(directive_defn)
+        end
 
-  class DirectiveStrategy
-    def push(stack, node)
-      directive_defn = stack.schema.directives[node.name]
-      stack.directive_definitions.push(directive_defn)
-    end
+        def pop(stack, node)
+          stack.directive_definitions.pop
+        end
+      end
 
-    def pop(stack, node)
-      stack.directive_definitions.pop
-    end
-  end
+      class ArgumentStrategy
+        # Push `argument_defn` onto the stack.
+        # It's possible that `argument_defn` will be nil.
+        # Push it anyways so `pop` has something to pop.
+        def push(stack, node)
+          if stack.argument_definitions.last
+            arg_type = stack.argument_definitions.last.type.unwrap
+            if arg_type.kind.input_object?
+              argument_defn = arg_type.input_fields[node.name]
+            else
+              argument_defn = nil
+            end
+          elsif stack.directive_definitions.last
+            argument_defn = stack.directive_definitions.last.arguments[node.name]
+          elsif stack.field_definitions.last
+            argument_defn = stack.field_definitions.last.arguments[node.name]
+          else
+            argument_defn = nil
+          end
+          stack.argument_definitions.push(argument_defn)
+        end
 
-  class ArgumentStrategy
-    # Push `argument_defn` onto the stack.
-    # It's possible that `argument_defn` will be nil.
-    # Push it anyways so `pop` has something to pop.
-    def push(stack, node)
-      if stack.argument_definitions.last
-        arg_type = stack.argument_definitions.last.type.unwrap
-        if arg_type.kind.input_object?
-          argument_defn = arg_type.input_fields[node.name]
-        else
-          argument_defn = nil
+        def pop(stack, node)
+          stack.argument_definitions.pop
         end
-      elsif stack.directive_definitions.last
-        argument_defn = stack.directive_definitions.last.arguments[node.name]
-      elsif stack.field_definitions.last
-        argument_defn = stack.field_definitions.last.arguments[node.name]
-      else
-        argument_defn = nil
       end
-      stack.argument_definitions.push(argument_defn)
-    end
 
-    def pop(stack, node)
-      stack.argument_definitions.pop
+      # A no-op strategy (don't handle this node)
+      class NullStrategy
+        def self.new; self; end
+        def self.push(stack, node);  end
+        def self.pop(stack, node);   end
+      end
     end
   end
-
-  # A no-op strategy (don't handle this node)
-  class NullStrategy
-    def self.new; self; end
-    def self.push(stack, node);  end
-    def self.pop(stack, node);   end
-  end
 end