Merge pull request #4876 from rmosolgo/context-clean-ups

Remove old Context structure

Author: rmosolgo

lib/graphql/backtrace/inspect_result.rb

@@ -16,12 +16,6 @@ def inspect_result(obj)
           "[" +
             obj.map { |v| inspect_truncated(v) }.join(", ") +
             "]"
-        when Query::Context::SharedMethods
-          if obj.invalid_null?
-            "nil"
-          else
-            inspect_truncated(obj.value)
-          end
         else
           inspect_truncated(obj)
         end
@@ -33,12 +27,6 @@ def inspect_truncated(obj)
           "{...}"
         when Array
           "[...]"
-        when Query::Context::SharedMethods
-          if obj.invalid_null?
-            "nil"
-          else
-            inspect_truncated(obj.value)
-          end
         when GraphQL::Execution::Lazy
           "(unresolved)"
         else

lib/graphql/language/document_from_schema_definition.rb

@@ -24,7 +24,7 @@ def initialize(
         @include_built_in_directives = include_built_in_directives
         @include_one_of = false
 
-        schema_context = schema.context_class.new(query: nil, object: nil, schema: schema, values: context)
+        schema_context = schema.context_class.new(query: nil, schema: schema, values: context)
 
 
         @warden = @schema.warden_class.new(

lib/graphql/query.rb

@@ -99,7 +99,7 @@ def initialize(schema, query_string = nil, query: nil, document: nil, context: n
       # Even if `variables: nil` is passed, use an empty hash for simpler logic
       variables ||= {}
       @schema = schema
-      @context = schema.context_class.new(query: self, object: root_value, values: context)
+      @context = schema.context_class.new(query: self, values: context)
       @warden = warden
       @subscription_topic = subscription_topic
       @root_value = root_value

lib/graphql/query/context.rb

@@ -6,36 +6,6 @@ class Query
     # Expose some query-specific info to field resolve functions.
     # It delegates `[]` to the hash that's passed to `GraphQL::Query#initialize`.
     class Context
-      module SharedMethods
-        # Return this value to tell the runtime
-        # to exclude this field from the response altogether
-        def skip
-          GraphQL::Execution::SKIP
-        end
-
-        # Add error at query-level.
-        # @param error [GraphQL::ExecutionError] an execution error
-        # @return [void]
-        def add_error(error)
-          if !error.is_a?(ExecutionError)
-            raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
-          end
-          errors << error
-          nil
-        end
-
-        # @example Print the GraphQL backtrace during field resolution
-        #   puts ctx.backtrace
-        #
-        # @return [GraphQL::Backtrace] The backtrace for this point in query execution
-        def backtrace
-          GraphQL::Backtrace.new(self)
-        end
-
-        def execution_errors
-          @execution_errors ||= ExecutionErrors.new(self)
-        end
-      end
 
       class ExecutionErrors
         def initialize(ctx)
@@ -59,7 +29,6 @@ def add(err_or_msg)
         alias :push :add
       end
 
-      include SharedMethods
       extend Forwardable
 
       # @return [Array<GraphQL::ExecutionError>] errors returned during execution
@@ -77,11 +46,10 @@ def add(err_or_msg)
       # Make a new context which delegates key lookup to `values`
       # @param query [GraphQL::Query] the query who owns this context
       # @param values [Hash] A hash of arbitrary values which will be accessible at query-time
-      def initialize(query:, schema: query.schema, values:, object:)
+      def initialize(query:, schema: query.schema, values:)
         @query = query
         @schema = schema
         @provided_values = values || {}
-        @object = object
         # Namespaced storage, where user-provided values are in `nil` namespace:
         @storage = Hash.new { |h, k| h[k] = {} }
         @storage[nil] = @provided_values
@@ -140,6 +108,35 @@ def [](key)
         end
       end
 
+      # Return this value to tell the runtime
+      # to exclude this field from the response altogether
+      def skip
+        GraphQL::Execution::SKIP
+      end
+
+      # Add error at query-level.
+      # @param error [GraphQL::ExecutionError] an execution error
+      # @return [void]
+      def add_error(error)
+        if !error.is_a?(ExecutionError)
+          raise TypeError, "expected error to be a ExecutionError, but was #{error.class}"
+        end
+        errors << error
+        nil
+      end
+
+      # @example Print the GraphQL backtrace during field resolution
+      #   puts ctx.backtrace
+      #
+      # @return [GraphQL::Backtrace] The backtrace for this point in query execution
+      def backtrace
+        GraphQL::Backtrace.new(self)
+      end
+
+      def execution_errors
+        @execution_errors ||= ExecutionErrors.new(self)
+      end
+
       def current_path
         current_runtime_state = Thread.current[:__graphql_runtime_info]
         query_runtime_state = current_runtime_state && current_runtime_state[@query]

spec/graphql/query/context_spec.rb

@@ -61,7 +61,7 @@ def push_query_error
   end
 
   describe "empty values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil) }
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
 
     it "returns returns nil and reports key? => false" do
       assert_nil(context[:some_key])
@@ -71,7 +71,7 @@ def push_query_error
   end
 
   describe "assigning values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil) }
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
 
     it "allows you to assign new contexts" do
       assert_nil(context[:some_key])
@@ -80,7 +80,7 @@ def push_query_error
     end
 
     describe "namespaces" do
-      let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: 1}, object: nil) }
+      let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: 1}) }
 
       it "doesn't conflict with base values" do
         ns = context.namespace(:stuff)
@@ -92,7 +92,7 @@ def push_query_error
   end
 
   describe "read values" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}, object: nil) }
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}) }
 
     it "allows you to read values of contexts using []" do
       assert_equal({b: 1}, context[:a])
@@ -107,7 +107,7 @@ def push_query_error
   end
 
   describe "splatting" do
-    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}, object: nil) }
+    let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}) }
 
     let(:splat) { ->(**context) { context } }
 
@@ -117,7 +117,7 @@ def push_query_error
   end
 
   it "can override values set by runtime" do
-    context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}, object: nil)
+    context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}})
     Thread.current[:__graphql_runtime_info] = { context.query => OpenStruct.new({ current_object: :runtime_value }) }
     assert_equal :runtime_value, context[:current_object]
     context[:current_object] = :override_value
@@ -389,7 +389,7 @@ class ContextSchema < GraphQL::Schema
     end
 
     it "always retrieves a scoped context value if set" do
-      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil)
+      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil)
       dummy_runtime = OpenStruct.new(current_result: nil)
       Thread.current[:__graphql_runtime_info] = { context.query => dummy_runtime }
       dummy_runtime.current_result = OpenStruct.new(path: ["somewhere"])
@@ -443,15 +443,15 @@ class ContextSchema < GraphQL::Schema
       expected_key = :a
       expected_value = :test
 
-      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil)
+      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil)
       assert_nil(context[expected_key])
 
       context.scoped_set!(expected_key, expected_value)
       assert_equal(expected_value, context[expected_key])
     end
 
     it "has a #current_path method" do
-      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil)
+      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil)
       current_result = OpenStruct.new(path: ["somewhere", "child", "grandchild"])
       Thread.current[:__graphql_runtime_info] = { context.query => OpenStruct.new(current_result: current_result) }
       assert_equal ["somewhere", "child", "grandchild"], context.scoped_context.current_path

spec/graphql/schema/warden_spec.rb

@@ -1009,7 +1009,7 @@ def self.visible?(member, context)
     end
 
     it "uses PassThruWarden when a warden on the context nor query" do
-      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: GraphQL::Schema.new), values: {}, object: nil)
+      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: GraphQL::Schema.new), values: {})
       assert_equal GraphQL::Schema::Warden::PassThruWarden, GraphQL::Schema::Warden.from_context(context)
     end
   end