graphql 2.0.21 → 2.0.32

data/lib/graphql/language/parser.y

@@ -150,6 +150,7 @@ rule
     | REPEATABLE
     | TRUE
     | FALSE
+    | NULL
     | operation_type
     | schema_keyword
 

data/lib/graphql/language/printer.rb

@@ -131,7 +131,7 @@ module GraphQL
         "$#{variable_identifier.name}".dup
       end
 
-      def print_schema_definition(schema)
+      def print_schema_definition(schema, extension: false)
         has_conventional_names = (schema.query.nil? || schema.query == 'Query') &&
           (schema.mutation.nil? || schema.mutation == 'Mutation') &&
           (schema.subscription.nil? || schema.subscription == 'Subscription')
@@ -140,7 +140,7 @@ module GraphQL
           return
         end
 
-        out = "schema".dup
+        out = extension ? "extend schema".dup : "schema".dup
         if schema.directives.any?
           schema.directives.each do |dir|
             out << "\n  "
@@ -164,14 +164,14 @@ module GraphQL
         out
       end
 
-      def print_scalar_type_definition(scalar_type)
-        out = print_description(scalar_type)
+      def print_scalar_type_definition(scalar_type, extension: false)
+        out = extension ? "extend ".dup : print_description(scalar_type)
         out << "scalar #{scalar_type.name}"
         out << print_directives(scalar_type.directives)
       end
 
-      def print_object_type_definition(object_type)
-        out = print_description(object_type)
+      def print_object_type_definition(object_type, extension: false)
+        out = extension ? "extend ".dup : print_description(object_type)
         out << "type #{object_type.name}"
         out << print_implements(object_type) unless object_type.interfaces.empty?
         out << print_directives(object_type.directives)
@@ -210,23 +210,23 @@ module GraphQL
         out << print_directives(field.directives)
       end
 
-      def print_interface_type_definition(interface_type)
-        out = print_description(interface_type)
+      def print_interface_type_definition(interface_type, extension: false)
+        out = extension ? "extend ".dup : print_description(interface_type)
         out << "interface #{interface_type.name}"
         out << print_implements(interface_type) if interface_type.interfaces.any?
         out << print_directives(interface_type.directives)
         out << print_field_definitions(interface_type.fields)
       end
 
-      def print_union_type_definition(union_type)
-        out = print_description(union_type)
+      def print_union_type_definition(union_type, extension: false)
+        out = extension ? "extend ".dup : print_description(union_type)
         out << "union #{union_type.name}"
         out << print_directives(union_type.directives)
         out << " = " + union_type.types.map(&:name).join(" | ")
       end
 
-      def print_enum_type_definition(enum_type)
-        out = print_description(enum_type)
+      def print_enum_type_definition(enum_type, extension: false)
+        out = extension ? "extend ".dup : print_description(enum_type)
         out << "enum #{enum_type.name}#{print_directives(enum_type.directives)} {\n"
         enum_type.values.each.with_index do |value, i|
           out << print_description(value, indent: '  ', first_in_block: i == 0)
@@ -241,8 +241,8 @@ module GraphQL
         out << "\n"
       end
 
-      def print_input_object_type_definition(input_object_type)
-        out = print_description(input_object_type)
+      def print_input_object_type_definition(input_object_type, extension: false)
+        out = extension ? "extend ".dup : print_description(input_object_type)
         out << "input #{input_object_type.name}"
         out << print_directives(input_object_type.directives)
         if !input_object_type.fields.empty?
@@ -347,24 +347,38 @@ module GraphQL
           print_variable_identifier(node)
         when Nodes::SchemaDefinition
           print_schema_definition(node)
+        when Nodes::SchemaExtension
+          print_schema_definition(node, extension: true)
         when Nodes::ScalarTypeDefinition
           print_scalar_type_definition(node)
+        when Nodes::ScalarTypeExtension
+          print_scalar_type_definition(node, extension: true)
         when Nodes::ObjectTypeDefinition
           print_object_type_definition(node)
+        when Nodes::ObjectTypeExtension
+          print_object_type_definition(node, extension: true)
         when Nodes::InputValueDefinition
           print_input_value_definition(node)
         when Nodes::FieldDefinition
           print_field_definition(node)
         when Nodes::InterfaceTypeDefinition
           print_interface_type_definition(node)
+        when Nodes::InterfaceTypeExtension
+          print_interface_type_definition(node, extension: true)
         when Nodes::UnionTypeDefinition
           print_union_type_definition(node)
+        when Nodes::UnionTypeExtension
+          print_union_type_definition(node, extension: true)
         when Nodes::EnumTypeDefinition
           print_enum_type_definition(node)
+        when Nodes::EnumTypeExtension
+          print_enum_type_definition(node, extension: true)
         when Nodes::EnumValueDefinition
           print_enum_value_definition(node)
         when Nodes::InputObjectTypeDefinition
           print_input_object_type_definition(node)
+        when Nodes::InputObjectTypeExtension
+          print_input_object_type_definition(node, extension: true)
         when Nodes::DirectiveDefinition
           print_directive_definition(node)
         when FalseClass, Float, Integer, NilClass, String, TrueClass, Symbol

data/lib/graphql/language/visitor.rb

@@ -76,67 +76,6 @@ module GraphQL
         end
       end
 
-      # We don't use `alias` here because it breaks `super`
-      def self.make_visit_methods(ast_node_class)
-        node_method = ast_node_class.visit_method
-        children_of_type = ast_node_class.children_of_type
-        child_visit_method = :"#{node_method}_children"
-
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          # The default implementation for visiting an AST node.
-          # It doesn't _do_ anything, but it continues to visiting the node's children.
-          # To customize this hook, override one of its make_visit_methods (or the base method?)
-          # in your subclasses.
-          #
-          # For compatibility, it calls hook procs, too.
-          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
-          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
-          # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
-          def #{node_method}(node, parent)
-            if node.equal?(DELETE_NODE)
-              # This might be passed to `super(DELETE_NODE, ...)`
-              # by a user hook, don't want to keep visiting in that case.
-              [node, parent]
-            else
-              # Run hooks if there are any
-              new_node = node
-              no_hooks = !@visitors.key?(node.class)
-              if no_hooks || begin_visit(new_node, parent)
-                #{
-                  if method_defined?(child_visit_method)
-                    "new_node = #{child_visit_method}(new_node)"
-                  elsif children_of_type
-                    children_of_type.map do |child_accessor, child_class|
-                      "node.#{child_accessor}.each do |child_node|
-                        new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
-                        # Reassign `node` in case the child hook makes a modification
-                        if new_child_and_node.is_a?(Array)
-                          new_node = new_child_and_node[1]
-                        end
-                      end"
-                    end.join("\n")
-                  else
-                    ""
-                  end
-                }
-              end
-              end_visit(new_node, parent) unless no_hooks
-
-              if new_node.equal?(node)
-                [node, parent]
-              else
-                [new_node, parent]
-              end
-            end
-          end
-
-          def #{node_method}_with_modifications(node, parent)
-            new_node_and_new_parent = #{node_method}(node, parent)
-            apply_modifications(node, parent, new_node_and_new_parent)
-          end
-        RUBY
-      end
-
       def on_document_children(document_node)
         new_node = document_node
         document_node.children.each do |child_node|
@@ -237,6 +176,68 @@ module GraphQL
         new_node
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # The default implementation for visiting an AST node.
+          # It doesn't _do_ anything, but it continues to visiting the node's children.
+          # To customize this hook, override one of its make_visit_methods (or the base method?)
+          # in your subclasses.
+          #
+          # For compatibility, it calls hook procs, too.
+          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+          # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
+          def #{node_method}(node, parent)
+            if node.equal?(DELETE_NODE)
+              # This might be passed to `super(DELETE_NODE, ...)`
+              # by a user hook, don't want to keep visiting in that case.
+              [node, parent]
+            else
+              # Run hooks if there are any
+              new_node = node
+              no_hooks = !@visitors.key?(node.class)
+              if no_hooks || begin_visit(new_node, parent)
+                #{
+                  if method_defined?(child_visit_method)
+                    "new_node = #{child_visit_method}(new_node)"
+                  elsif children_of_type
+                    children_of_type.map do |child_accessor, child_class|
+                      "node.#{child_accessor}.each do |child_node|
+                        new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
+                        # Reassign `node` in case the child hook makes a modification
+                        if new_child_and_node.is_a?(Array)
+                          new_node = new_child_and_node[1]
+                        end
+                      end"
+                    end.join("\n")
+                  else
+                    ""
+                  end
+                }
+              end
+              end_visit(new_node, parent) unless no_hooks
+              if new_node.equal?(node)
+                [node, parent]
+              else
+                [new_node, parent]
+              end
+            end
+          end
+          def #{node_method}_with_modifications(node, parent)
+            new_node_and_new_parent = #{node_method}(node, parent)
+            apply_modifications(node, parent, new_node_and_new_parent)
+          end
+        RUBY
+      end
+
+
+
       [
         Language::Nodes::Argument,
         Language::Nodes::Directive,
@@ -277,6 +278,8 @@ module GraphQL
         make_visit_methods(ast_node_class)
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       private
 
       def apply_modifications(node, parent, new_node_and_new_parent)

data/lib/graphql/query/context.rb

@@ -227,7 +227,8 @@ module GraphQL
             current_path
           else
             (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
-              (current_runtime_state.public_send(key))
+              (query_runtime_state = current_runtime_state[@query]) &&
+              (query_runtime_state.public_send(key))
           end
         else
           # not found
@@ -237,10 +238,12 @@ module GraphQL
 
       def current_path
         current_runtime_state = Thread.current[:__graphql_runtime_info]
-        path = current_runtime_state &&
-          (result = current_runtime_state.current_result) &&
+        query_runtime_state = current_runtime_state && current_runtime_state[@query]
+
+        path = query_runtime_state &&
+          (result = query_runtime_state.current_result) &&
           (result.path)
-        if path && (rn = current_runtime_state.current_result_name)
+        if path && (rn = query_runtime_state.current_result_name)
           path = path.dup
           path.push(rn)
         end
@@ -260,7 +263,8 @@ module GraphQL
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
         if RUNTIME_METADATA_KEYS.include?(key)
           (runtime = Thread.current[:__graphql_runtime_info]) &&
-            (runtime.public_send(key))
+            (query_runtime_state = runtime[@query]) &&
+            (query_runtime_state.public_send(key))
         elsif @scoped_context.key?(key)
           scoped_context[key]
         elsif @provided_values.key?(key)
@@ -277,8 +281,13 @@ module GraphQL
       def dig(key, *other_keys)
         if RUNTIME_METADATA_KEYS.include?(key)
           (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
-            (obj = current_runtime_state.public_send(key)) &&
-            obj.dig(*other_keys)
+            (query_runtime_state = current_runtime_state[@query]) &&
+            (obj = query_runtime_state.public_send(key)) &&
+            if other_keys.empty?
+              obj
+            else
+              obj.dig(*other_keys)
+            end
         elsif @scoped_context.key?(key)
           @scoped_context.dig(key, *other_keys)
         else

data/lib/graphql/query/null_context.rb

@@ -3,35 +3,27 @@ module GraphQL
   class Query
     # This object can be `ctx` in places where there is no query
     class NullContext
-      class NullWarden < GraphQL::Schema::Warden
-        def visible_field?(field, ctx); true; end
-        def visible_argument?(arg, ctx); true; end
-        def visible_type?(type, ctx); true; end
-        def visible_enum_value?(ev, ctx); true; end
-        def visible_type_membership?(tm, ctx); true; end
-      end
-
       class NullQuery
+        def after_lazy(value)
+          yield(value)
+        end
       end
 
       class NullSchema < GraphQL::Schema
       end
 
+      extend Forwardable
+
       attr_reader :schema, :query, :warden, :dataloader
+      def_delegators GraphQL::EmptyObjects::EMPTY_HASH, :[], :fetch, :dig, :key?
 
       def initialize
         @query = NullQuery.new
         @dataloader = GraphQL::Dataloader::NullDataloader.new
         @schema = NullSchema
-        @warden = NullWarden.new(
-          GraphQL::Filter.new(silence_deprecation_warning: true),
-          context: self,
-          schema: @schema,
-        )
+        @warden = Schema::Warden::NullWarden.new(context: self, schema: @schema)
       end
 
-      def [](key); end
-
       def interpreter?
         true
       end
@@ -39,13 +31,11 @@ module GraphQL
       class << self
         extend Forwardable
 
-        def [](key); end
-
         def instance
           @instance ||= self.new
         end
 
-        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader
+        def_delegators :instance, :query, :warden, :schema, :interpreter?, :dataloader, :[], :fetch, :dig, :key?
       end
     end
   end

data/lib/graphql/query/validation_pipeline.rb

@@ -68,7 +68,8 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
+          validator = @query.static_validator || @schema.static_validator
+          validation_result = validator.validate(@query, validate: @query.validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
 
           if @validation_errors.empty?

data/lib/graphql/query.rb

@@ -45,6 +45,20 @@ module GraphQL
       end
     end
 
+    # @return [GraphQL::StaticValidation::Validator] if present, the query will validate with these rules.
+    attr_reader :static_validator
+
+    # @param new_validate [GraphQL::StaticValidation::Validator] if present, the query will validate with these rules. This can't be reasssigned after validation.
+    def static_validator=(new_validator)
+      if defined?(@validation_pipeline) && @validation_pipeline && @validation_pipeline.has_validated?
+        raise ArgumentError, "Can't reassign Query#static_validator= after validation has run, remove this assignment."
+      elsif !new_validator.is_a?(GraphQL::StaticValidation::Validator)
+        raise ArgumentError, "Expected a `GraphQL::StaticValidation::Validator` instance."
+      else
+        @static_validator = new_validator
+      end
+    end
+
     attr_writer :query_string
 
     # @return [GraphQL::Language::Nodes::Document]
@@ -83,11 +97,13 @@ module GraphQL
     # @param max_complexity [Numeric] the maximum field complexity for this query (falls back to schema-level value)
     # @param except [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns truthy
     # @param only [<#call(schema_member, context)>] If provided, objects will be hidden from the schema when `.call(schema_member, context)` returns false
-    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
+    def initialize(schema, query_string = nil, query: nil, document: nil, context: nil, variables: nil, validate: true, static_validator: nil, subscription_topic: nil, operation_name: nil, root_value: nil, max_depth: schema.max_depth, max_complexity: schema.max_complexity, except: nil, only: nil, warden: nil)
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
-      @filter = schema.default_filter.merge(except: except, only: only)
+      if only || except
+        merge_filters(except: except, only: only)
+      end
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
       @subscription_topic = subscription_topic
@@ -95,12 +111,13 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
+      self.static_validator = static_validator if static_validator
       context_tracers = (context ? context.fetch(:tracers, []) : [])
       @tracers = schema.tracers + context_tracers
 
       # Support `ctx[:backtrace] = true` for wrapping backtraces
       if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-        if schema.trace_class <= GraphQL::Tracing::LegacyTrace
+        if schema.trace_class <= GraphQL::Tracing::CallLegacyTracers
           context_tracers += [GraphQL::Backtrace::Tracer]
           @tracers << GraphQL::Backtrace::Tracer
         elsif !(current_trace.class <= GraphQL::Backtrace::Trace)
@@ -108,8 +125,8 @@ module GraphQL
         end
       end
 
-      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::LegacyTrace)
-        raise ArgumentError, "context[:tracers] are not supported without `trace_class(GraphQL::Tracing::LegacyTrace)` in the schema configuration, please add it."
+      if context_tracers.any? && !(schema.trace_class <= GraphQL::Tracing::CallLegacyTracers)
+        raise ArgumentError, "context[:tracers] are not supported without `trace_with(GraphQL::Tracing::CallLegacyTracers)` in the schema configuration, please add it."
       end
 
 
@@ -151,11 +168,6 @@ module GraphQL
 
       @result_values = nil
       @executed = false
-
-      # TODO add a general way to define schema-level filters
-      if @schema.respond_to?(:visible?)
-        merge_filters(only: @schema.method(:visible?))
-      end
     end
 
     # If a document was provided to `GraphQL::Schema#execute` instead of the raw query string, we will need to get it from the document
@@ -171,7 +183,7 @@ module GraphQL
 
     # @return [GraphQL::Tracing::Trace]
     def current_trace
-      @current_trace ||= multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self)
+      @current_trace ||= context[:trace] || (multiplex ? multiplex.current_trace : schema.new_trace(multiplex: multiplex, query: self))
     end
 
     def subscription_update?
@@ -347,6 +359,7 @@ module GraphQL
       if @prepared_ast
         raise "Can't add filters after preparing the query"
       else
+        @filter ||= @schema.default_filter
         @filter = @filter.merge(only: only, except: except)
       end
       nil
@@ -361,6 +374,18 @@ module GraphQL
       schema.handle_or_reraise(context, err)
     end
 
+    def after_lazy(value, &block)
+      if !defined?(@runtime_instance)
+        @runtime_instance = context.namespace(:interpreter_runtime)[:runtime]
+      end
+
+      if @runtime_instance
+        @runtime_instance.minimal_after_lazy(value, &block)
+      else
+        @schema.after_lazy(value, &block)
+      end
+    end
+
     private
 
     def find_operation(operations, operation_name)
@@ -375,7 +400,7 @@ module GraphQL
 
     def prepare_ast
       @prepared_ast = true
-      @warden ||= GraphQL::Schema::Warden.new(@filter, schema: @schema, context: @context)
+      @warden ||= @schema.warden_class.new(@filter, schema: @schema, context: @context)
       parse_error = nil
       @document ||= begin
         if query_string

data/lib/graphql/schema/addition.rb

@@ -40,14 +40,21 @@ module GraphQL
       end
 
       def add_directives_from(owner)
-        dirs = owner.directives.map(&:class)
-        @directives.merge(dirs)
-        add_type_and_traverse(dirs)
+        if (dir_instances = owner.directives).any?
+          dirs = dir_instances.map(&:class)
+          @directives.merge(dirs)
+          add_type_and_traverse(dirs)
+        end
       end
 
       def add_type_and_traverse(new_types)
         late_types = []
-        new_types.each { |t| add_type(t, owner: nil, late_types: late_types, path: [t.graphql_name]) }
+        path = []
+        new_types.each do |t|
+          path.push(t.graphql_name)
+          add_type(t, owner: nil, late_types: late_types, path: path)
+          path.pop
+        end
         missed_late_types = 0
         while (late_type_vals = late_types.shift)
           type_owner, lt = late_type_vals
@@ -158,7 +165,9 @@ module GraphQL
           type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
             references_to(arg_type, from: arg)
-            add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
+            path.push(arg.graphql_name)
+            add_type(arg_type, owner: arg, late_types: late_types, path: path)
+            path.pop
             if arg.default_value?
               @arguments_with_default_values << arg
             end
@@ -179,18 +188,21 @@ module GraphQL
               name = field.graphql_name
               field_type = field.type.unwrap
               references_to(field_type, from: field)
-              field_path = path + [name]
-              add_type(field_type, owner: field, late_types: late_types, path: field_path)
+              path.push(name)
+              add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
                 references_to(arg_type, from: arg)
-                add_type(arg_type, owner: arg, late_types: late_types, path: field_path + [arg.graphql_name])
+                path.push(arg.graphql_name)
+                add_type(arg_type, owner: arg, late_types: late_types, path: path)
+                path.pop
                 if arg.default_value?
                   @arguments_with_default_values << arg
                 end
               end
+              path.pop
             end
           end
           if type.kind.input_object?
@@ -198,7 +210,9 @@ module GraphQL
               add_directives_from(arg)
               arg_type = arg.type.unwrap
               references_to(arg_type, from: arg)
-              add_type(arg_type, owner: arg, late_types: late_types, path: path + [arg.graphql_name])
+              path.push(arg.graphql_name)
+              add_type(arg_type, owner: arg, late_types: late_types, path: path)
+              path.pop
               if arg.default_value?
                 @arguments_with_default_values << arg
               end
@@ -206,14 +220,18 @@ module GraphQL
           end
           if type.kind.union?
             @possible_types[type.graphql_name] = type.all_possible_types
+            path.push("possible_types")
             type.all_possible_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["possible_types"])
+              add_type(t, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
           if type.kind.interface?
+            path.push("orphan_types")
             type.orphan_types.each do |t|
-              add_type(t, owner: type, late_types: late_types, path: path + ["orphan_types"])
+              add_type(t, owner: type, late_types: late_types, path: path)
             end
+            path.pop
           end
           if type.kind.object?
             possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
@@ -221,6 +239,7 @@ module GraphQL
           end
 
           if type.kind.object? || type.kind.interface?
+            path.push("implements")
             type.interface_type_memberships.each do |interface_type_membership|
               case interface_type_membership
               when Schema::TypeMembership
@@ -235,7 +254,14 @@ module GraphQL
               else
                 raise ArgumentError, "Invariant: unexpected type membership for #{type.graphql_name}: #{interface_type_membership.class} (#{interface_type_membership.inspect})"
               end
-              add_type(interface_type, owner: type, late_types: late_types, path: path + ["implements"])
+              add_type(interface_type, owner: type, late_types: late_types, path: path)
+            end
+            path.pop
+          end
+
+          if type.kind.enum?
+            type.all_enum_value_definitions.each do |value_definition|
+              add_directives_from(value_definition)
             end
           end
         end

data/lib/graphql/schema/always_visible.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class AlwaysVisible
+      def self.use(schema, **opts)
+        schema.warden_class = GraphQL::Schema::Warden::NullWarden
+      end
+    end
+  end
+end