graphql-client 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 490142029326d682bd6956d1f825d9429aa49389
-  data.tar.gz: 3cc776110140c024c801f8b3a9eb52bf72cc924f
+  metadata.gz: 88afea7eaa70819f11b2a000886ef3924e2b0e12
+  data.tar.gz: 62a8706efe7fe20a73da2affaa3e362dce686970
 SHA512:
-  metadata.gz: 2e3cba4f02d0fff593cadcbd0d39bcdecb0576f087bb9088f2dc5902426bb54b7829ea3eb7d8d96c86fae155eb6ba248c5414ba24006834c8a4d806063e1be4c
-  data.tar.gz: bb8b0a56f1f1d0be7a4315aa626af65a08e7285adb03fb02e382a0fb6fdb53e67326ed6654f171709f267897141e396813ac2245f6c45097157b78f492dba7da
+  metadata.gz: b9774d7f5229a0202924ff253b251076ed7b5f71dd3e32f0707467663868faace9a331b79878e70159058ebbdde59b477892b13c662c1e3f9492fa31e6901551
+  data.tar.gz: 0d4e18520e7b23a28012edf77a98913358ef7793e70f46ddbdf881ad63c51eafc83325ef7a388d37b752914d55b0f6e9d23dc50efbb23afc98bf1f5aebd25be0

data/lib/graphql/client.rb

@@ -2,6 +2,7 @@
 require "active_support/inflector"
 require "active_support/notifications"
 require "graphql"
+require "graphql/client/collocated_enforcement"
 require "graphql/client/error"
 require "graphql/client/errors"
 require "graphql/client/query_result"
@@ -22,10 +23,15 @@ module GraphQL
     class NotImplementedError < Error; end
     class ValidationError < Error; end
 
+    extend CollocatedEnforcement
+
     attr_reader :schema, :execute
 
     attr_accessor :document_tracking_enabled
 
+    # Public: Check if collocated caller enforcement is enabled.
+    attr_reader :enforce_collocated_callers
+
     # Deprecated: Allow dynamically generated queries to be passed to
     # Client#query.
     #
@@ -72,12 +78,13 @@ module GraphQL
       result
     end
 
-    def initialize(schema: nil, execute: nil)
+    def initialize(schema: nil, execute: nil, enforce_collocated_callers: false)
       @schema = self.class.load_schema(schema)
       @execute = execute
       @document = GraphQL::Language::Nodes::Document.new(definitions: [])
       @document_tracking_enabled = false
       @allow_dynamic_queries = false
+      @enforce_collocated_callers = enforce_collocated_callers
     end
 
     # Definitions are constructed by Client.parse and wrap a parsed AST of the
@@ -97,11 +104,13 @@ module GraphQL
         end
       end
 
-      def initialize(node:, document:, schema:, document_types:)
+      def initialize(node:, document:, schema:, document_types:, source_location:, enforce_collocated_callers:)
         @definition_node = node
         @document = document
         @schema = schema
         @document_types = document_types
+        @source_location = source_location
+        @enforce_collocated_callers = enforce_collocated_callers
       end
 
       # Internal: Get underlying operation or fragment defintion AST node for
@@ -134,15 +143,26 @@ module GraphQL
       # and any FragmentDefinition dependencies.
       attr_reader :document
 
+      # Internal: Mapping of document nodes to schema types.
+      attr_reader :document_types
+
       attr_reader :schema
 
+      # Public: Returns the Ruby source filename and line number containing this
+      # definition was not defined in Ruby.
+      #
+      # Returns Array pair of [String, Fixnum].
+      attr_reader :source_location
+
+      attr_reader :enforce_collocated_callers
+
       def new(*args)
         type.new(*args)
       end
 
       def type
         # TODO: Fix type indirection
-        @type ||= GraphQL::Client::QueryResult.wrap(definition_node, name: "#{name}.type", types: @document_types)
+        @type ||= GraphQL::Client::QueryResult.wrap(self, definition_node, name: "#{name}.type")
       end
     end
 
@@ -158,11 +178,22 @@ module GraphQL
     end
 
     def parse(str, filename = nil, lineno = nil)
-      if filename.nil? || lineno.nil?
-        filename, lineno, = caller(1, 1).first.split(":", 3)
-        lineno = lineno.to_i
+      if filename.nil? && lineno.nil?
+        location = caller_locations(1, 1).first
+        filename = location.path
+        lineno = location.lineno
       end
 
+      unless filename.is_a?(String)
+        raise TypeError, "expected filename to be a String, but was #{filename.class}"
+      end
+
+      unless lineno.is_a?(Integer)
+        raise TypeError, "expected lineno to be a Integer, but was #{lineno.class}"
+      end
+
+      source_location = [filename, lineno].freeze
+
       definition_dependencies = Set.new
 
       str = str.gsub(/\.\.\.([a-zA-Z0-9_]+(::[a-zA-Z0-9_]+)+)/) do
@@ -186,9 +217,7 @@ module GraphQL
                     end
 
           error = ValidationError.new(message)
-          if filename && lineno
-            error.set_backtrace(["#{filename}:#{lineno + match.pre_match.count("\n") + 1}"] + caller)
-          end
+          error.set_backtrace(["#{filename}:#{lineno + match.pre_match.count("\n") + 1}"] + caller)
           raise error
         end
       end
@@ -211,7 +240,7 @@ module GraphQL
           error_hash = error.to_h
           validation_line = error_hash["locations"][0]["line"]
           error = ValidationError.new(error_hash["message"])
-          error.set_backtrace(["#{filename}:#{lineno + validation_line}"] + caller) if filename && lineno
+          error.set_backtrace(["#{filename}:#{lineno + validation_line}"] + caller)
           raise error
         end
 
@@ -230,7 +259,9 @@ module GraphQL
           schema: @schema,
           node: node,
           document: sliced_document,
-          document_types: document_types
+          document_types: document_types,
+          source_location: source_location,
+          enforce_collocated_callers: enforce_collocated_callers
         )
         definitions[node.name] = definition
       end

data/lib/graphql/client/collocated_enforcement.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require "graphql/client/error"
+
+module GraphQL
+  class Client
+    # Raised when method is called from outside the expected file scope.
+    class NonCollocatedCallerError < Error; end
+
+    # Enforcements collocated object access best practices.
+    module CollocatedEnforcement
+      # Public: Ignore collocated caller enforcement for the scope of the block.
+      def allow_noncollocated_callers
+        Thread.current[:query_result_caller_location_ignore] = true
+        yield
+      ensure
+        Thread.current[:query_result_caller_location_ignore] = nil
+      end
+
+      # Internal: Decorate method with collocated caller enforcement.
+      #
+      # mod - Target Module/Class
+      # methods - Array of Symbol method names
+      # path - String filename to assert calling from
+      #
+      # Returns nothing.
+      def enforce_collocated_callers(mod, methods, path)
+        mod.prepend(Module.new do
+          methods.each do |method|
+            define_method(method) do |*args, &block|
+              return super(*args, &block) if Thread.current[:query_result_caller_location_ignore]
+
+              locations = caller_locations(1)
+              if locations.first.path != path
+                error = NonCollocatedCallerError.new("#{method} was called outside of '#{path}' https://git.io/v1syX")
+                error.set_backtrace(locations.map(&:to_s))
+                raise error
+              end
+
+              begin
+                Thread.current[:query_result_caller_location_ignore] = true
+                super(*args, &block)
+              ensure
+                Thread.current[:query_result_caller_location_ignore] = nil
+              end
+            end
+          end
+        end)
+      end
+    end
+  end
+end

data/lib/graphql/client/query_result.rb

@@ -17,7 +17,7 @@ module GraphQL
       # Internal: Get QueryResult class for result of query.
       #
       # Returns subclass of QueryResult or nil.
-      def self.wrap(node, name: nil, types: {})
+      def self.wrap(source_definition, node, name: nil)
         fields = {}
 
         node.selections.each do |selection|
@@ -27,40 +27,74 @@ module GraphQL
           when Language::Nodes::Field
             field_name = selection.alias || selection.name
             field_klass = nil
-            field_klass = wrap(selection, name: "#{name}[:#{field_name}]", types: types) if selection.selections.any?
+            if selection.selections.any?
+              field_klass = wrap(source_definition, selection, name: "#{name}[:#{field_name}]")
+            end
             fields[field_name] ? fields[field_name] |= field_klass : fields[field_name] = field_klass
           when Language::Nodes::InlineFragment
-            wrap(selection, name: name, types: types).fields.each do |fragment_name, klass|
+            wrap(source_definition, selection, name: name).fields.each do |fragment_name, klass|
               fields[fragment_name.to_s] ? fields[fragment_name.to_s] |= klass : fields[fragment_name.to_s] = klass
             end
           end
         end
 
-        define(name: name, source_node: node, fields: fields, type: types[node] && types[node].unwrap)
+        define(name: name, source_definition: source_definition, source_node: node, fields: fields)
+      end
+
+      # :nodoc:
+      class Scalar
+        def initialize(type)
+          @type = type
+        end
+
+        def cast(value, _errors = nil)
+          @type.coerce_input(value)
+        end
+
+        def |(_other)
+          # XXX: How would scalars merge?
+          self
+        end
       end
 
       # Internal
-      def self.define(name:, source_node:, fields: {}, type: nil)
+      def self.define(name:, source_definition:, source_node:, fields: {})
+        type = source_definition.document_types[source_node]
+        type = type.unwrap if type
+
         Class.new(self) do
           @name = name
           @type = type
           @source_node = source_node
+          @source_definition = source_definition
           @fields = {}
 
+          field_readers = Set.new
+
           fields.each do |field, klass|
+            if @type.is_a?(GraphQL::ObjectType)
+              field_node = @type.fields[field.to_s]
+              if field_node && field_node.type.unwrap.is_a?(GraphQL::ScalarType)
+                klass = Scalar.new(field_node.type.unwrap)
+              end
+            end
+
             @fields[field.to_sym] = klass
 
             send :attr_reader, field
+            field_readers << field.to_sym
 
             # Convert GraphQL camelcase to snake case: commitComments -> commit_comments
             field_alias = ActiveSupport::Inflector.underscore(field)
             send :alias_method, field_alias, field if field != field_alias
+            field_readers << field_alias.to_sym
 
             class_eval <<-RUBY, __FILE__, __LINE__
               def #{field_alias}?
                 #{field_alias} ? true : false
               end
             RUBY
+            field_readers << "#{field_alias}?".to_sym
 
             next unless field == "edges"
             class_eval <<-RUBY, __FILE__, __LINE__
@@ -70,9 +104,10 @@ module GraphQL
                 self
               end
             RUBY
+            field_readers << :each_node
           end
 
-          assigns = fields.map do |field, klass|
+          assigns = @fields.map do |field, klass|
             if klass
               <<-RUBY
                 @#{field} = self.class.fields[:#{field}].cast(@data["#{field}"], @errors.filter_by_path("#{field}"))
@@ -97,12 +132,18 @@ module GraphQL
               freeze
             end
           RUBY
+
+          if @source_definition.enforce_collocated_callers
+            Client.enforce_collocated_callers(self, field_readers, source_definition.source_location[0])
+          end
         end
       end
 
       class << self
         attr_reader :type
 
+        attr_reader :source_definition
+
         attr_reader :source_node
 
         attr_reader :fields
@@ -175,7 +216,7 @@ module GraphQL
           end
         end
         # TODO: Picking first source node seems error prone
-        define(name: self.name, source_node: source_node, fields: new_fields)
+        define(name: self.name, source_definition: source_definition, source_node: source_node, fields: new_fields)
       end
 
       # Public: Return errors associated with data.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql-client
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - GitHub
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-29 00:00:00.000000000 Z
+date: 2016-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -34,16 +34,16 @@ dependencies:
   name: graphql
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.2
+        version: '1.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.19.2
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: actionpack
   requirement: !ruby/object:Gem::Requirement
@@ -115,6 +115,7 @@ files:
 - LICENSE
 - README.md
 - lib/graphql/client.rb
+- lib/graphql/client/collocated_enforcement.rb
 - lib/graphql/client/document_types.rb
 - lib/graphql/client/error.rb
 - lib/graphql/client/errors.rb