graphql_includable 0.4.0.alpha.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0b4931965d11fc59002d2f514361dc3d30e0a17b
-  data.tar.gz: 2d0d4f23a686bd46d19d3447d989402364f16849
+  metadata.gz: c26fc967e743b93dc24703e364dc4500f17d94b9
+  data.tar.gz: 2c63040e1ed7695b36c9911fd44f6892d9c48c8f
 SHA512:
-  metadata.gz: 2be6bc900f6e21eadc3eafda2cf236a35b9d1366e67ace38d392ff4499b3a7bfb50576541edc994e5aa22d0a05018a1d9ba3dae2eef56e28323d8139f27e2ca9
-  data.tar.gz: c42a7b0b009ed5078e786bdbac8e2c25bcd6f192333bc40c02e3d74f96fa373809ddf3aa419be5e28f080a1b9e325574653284921d107a29b578cb56aa3dab23
+  metadata.gz: 7fda91af53b2e1057d0eb3acdaa251bda2b96b394f69445c309fe388a79ef6b0f4db76e694af58083b64676d5ced3a291fcbd82a3ad62064025637d08cd09e7d
+  data.tar.gz: 294fcbba508907345fc91a672e55a8305ff9702a89b0b34cbb0f397dbf64b15ef20fcb230c11ecf72281a6e12db4b7aafdcab0a5be554868e2410dee22844ba4

data/lib/graphql_includable/concern.rb

@@ -9,7 +9,6 @@ module GraphQLIncludable
         node = Resolver.find_node_by_return_type(ctx.irep_node, name)
         manager = IncludesManager.new(nil)
         Resolver.includes_for_node(node, manager)
-        puts "INCLUDES!!! #{manager.includes}"
         includes(manager.includes)
       rescue => e
         Rails.logger.error(e)

data/lib/graphql_includable/edge.rb

@@ -1,3 +1,6 @@
+# rubocop:disable Style/ConditionalAssignment
+# rubocop:disable Lint/HandleExceptions
+# rubocop:disable Metrics/AbcSize
 module GraphQLIncludable
   class Edge < GraphQL::Relay::Edge
     def edge
@@ -9,7 +12,7 @@ module GraphQLIncludable
       root_association_key = class_to_str(parent.class)
       unless edge_class.reflections.keys.include?(root_association_key)
         is_polymorphic = true
-        root_association_key = edge_class.reflections.select { |k, r| r.polymorphic? }.keys.first
+        root_association_key = edge_class.reflections.select { |_k, r| r.polymorphic? }.keys.first
       end
 
       if parent.class.delegate_cache&.key?(edge_class_name)
@@ -39,7 +42,7 @@ module GraphQLIncludable
       end
     end
 
-    def respond_to_missing(method_name, include_private = false)
+    def respond_to_missing?(method_name, include_private = false)
       edge.respond_to?(method_name) || super
     end
 

data/lib/graphql_includable/relay/edge_with_node.rb

@@ -3,7 +3,7 @@ module GraphQLIncludable
     class EdgeWithNode < GraphQL::Relay::Edge
       def initialize(node, connection)
         @edge = node
-        node = connection.edge_to_node(@edge)  # TODO: Make lazy
+        node = connection.edge_to_node(@edge) # TODO: Make lazy
         super(node, connection)
       end
 
@@ -15,7 +15,7 @@ module GraphQLIncludable
         end
       end
 
-      def respond_to_missing(method_name, include_private = false)
+      def respond_to_missing?(method_name, include_private = false)
         @edge.respond_to?(method_name) || super
       end
     end

data/lib/graphql_includable/relay/edge_with_node_connection.rb

@@ -1,9 +1,13 @@
 module GraphQLIncludable
   module Relay
     class ConnectionEdgesAndNodes
-      attr_reader :parent, :args, :ctx, :edges_property, :nodes_property, :edge_to_node_property, :edges_resolver, :nodes_resolver
+      attr_reader :parent, :args, :ctx, :edges_property, :nodes_property, :edge_to_node_property
+      attr_reader :edges_resolver, :nodes_resolver
 
-      def initialize(parent, args, ctx, edges_property, nodes_property, edge_to_node_property, edges_resolver, nodes_resolver)
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(parent, args, ctx,
+                     edges_property, nodes_property, edge_to_node_property,
+                     edges_resolver, nodes_resolver)
         @parent = parent
         @args = args
         @ctx = ctx
@@ -13,11 +17,12 @@ module GraphQLIncludable
         @edges_resolver = edges_resolver
         @nodes_resolver = nodes_resolver
       end
+      # rubocop:enable Metrics/ParameterLists
     end
 
     class EdgeWithNodeConnection < GraphQL::Relay::RelationConnection
       def initialize(nodes, *args, &block)
-        @connection_edges_and_nodes = nodes
+        @edges_and_nodes = nodes
         @loaded_nodes = nil
         @loaded_edges = nil
         super(nil, *args, &block)
@@ -28,14 +33,14 @@ module GraphQLIncludable
       end
 
       def fetch_edges
-        @loaded_edges ||= @connection_edges_and_nodes.edges_resolver.call(@connection_edges_and_nodes.parent, args, ctx)
+        @loaded_edges ||= @edges_and_nodes.edges_resolver.call(@edges_and_nodes.parent, args, ctx)
         # Set nodes to make underlying BaseConnection work
         @nodes = @loaded_edges
         @loaded_edges
       end
 
       def fetch_nodes
-        @loaded_nodes ||= @connection_edges_and_nodes.nodes_resolver.call(@connection_edges_and_nodes.parent, args, ctx)
+        @loaded_nodes ||= @edges_and_nodes.nodes_resolver.call(@edges_and_nodes.parent, args, ctx)
         # Set nodes to make underlying BaseConnection work
         @nodes = @loaded_nodes
         @loaded_nodes
@@ -47,7 +52,7 @@ module GraphQLIncludable
       end
 
       def edge_to_node(edge)
-        edge.public_send(@connection_edges_and_nodes.edge_to_node_property)
+        edge.public_send(@edges_and_nodes.edge_to_node_property)
       end
 
       def total_count
@@ -58,23 +63,23 @@ module GraphQLIncludable
       private
 
       def args
-        @connection_edges_and_nodes.args
+        @edges_and_nodes.args
       end
 
       def ctx
-        @connection_edges_and_nodes.ctx
+        @edges_and_nodes.ctx
       end
 
       def determin_page_info_nodes
-        # If the query asks for `pageInfo` before `edges` or `nodes`, we dont directly know which to use most efficently.
-        # We can have a guess by checking if either of the associations are preloaded
+        # If the query asks for `pageInfo` before `edges` or `nodes`, we dont directly know which to use most
+        # efficently. We can have a guess by checking if either of the associations are preloaded
         return @loaded_nodes if @loaded_nodes.present?
         return @loaded_edges if @loaded_edges.present?
 
-        nodes_preloaded = @connection_edges_and_nodes.parent.association(@connection_edges_and_nodes.nodes_property).loaded?
+        nodes_preloaded = @edges_and_nodes.parent.association(@edges_and_nodes.nodes_property).loaded?
         return fetch_nodes if nodes_preloaded
 
-        edges_preloaded = @connection_edges_and_nodes.parent.association(@connection_edges_and_nodes.edges_property).loaded?
+        edges_preloaded = @edges_and_nodes.parent.association(@edges_and_nodes.edges_property).loaded?
         return fetch_edges if edges_preloaded
 
         fetch_nodes

data/lib/graphql_includable/relay/edge_with_node_connection_type.rb

@@ -3,7 +3,8 @@ module GraphQLIncludable
     class EdgeWithNodeConnectionType
       def self.create_type(
         wrapped_type,
-        edge_type: wrapped_type.edge_type, edge_class: EdgeWithNode, nodes_field: GraphQL::Relay::ConnectionType.default_nodes_field, &block
+        edge_type: wrapped_type.edge_type, edge_class: EdgeWithNode,
+        nodes_field: GraphQL::Relay::ConnectionType.default_nodes_field, &block
       )
         custom_edge_class = edge_class
 
@@ -11,15 +12,19 @@ module GraphQLIncludable
           name("#{wrapped_type.name}Connection")
           description("The connection type for #{wrapped_type.name}.")
 
-          field :totalCount, types.Int, "Total count.", property: :total_count
+          field :totalCount, types.Int, 'Total count.', property: :total_count
 
-          field :edges, types[edge_type], "A list of edges.", edge_class: custom_edge_class, property: :fetch_edges, _includable_connection_marker: true
+          field :edges, types[edge_type], 'A list of edges.' do
+            edge_class custom_edge_class
+            property :fetch_edges
+            _includable_connection_marker true
+          end
 
           if nodes_field
-            field :nodes, types[wrapped_type],  "A list of nodes.", property: :fetch_nodes
+            field :nodes, types[wrapped_type], 'A list of nodes.', property: :fetch_nodes
           end
 
-          field :pageInfo, !GraphQL::Relay::PageInfo, "Information to aid in pagination.", property: :page_info
+          field :pageInfo, !GraphQL::Relay::PageInfo, 'Information to aid in pagination.', property: :page_info
           block && instance_eval(&block)
         end
       end

data/lib/graphql_includable/relay/instrumentation/connection.rb

@@ -2,10 +2,11 @@ module GraphQLIncludable
   module Relay
     module Instrumentation
       class Connection
+        # rubocop:disable Metrics/AbcSize
         def instrument(_type, field)
-          return field unless is_edge_with_node_connection?(field)
+          return field unless edge_with_node_connection?(field)
 
-          raise ArgumentError.new('Connection does not support fetching using :property') if field.property.present?
+          raise ArgumentError, 'Connection does not support fetching using :property' if field.property.present?
 
           validate!(field)
           edge_to_node_property = field.metadata[:edge_to_node_property]
@@ -13,55 +14,70 @@ module GraphQLIncludable
           edges_prop = explicit_includes[:edges]
           nodes_prop = explicit_includes[:nodes]
 
-          if is_proc_based?(field)
+          if proc_based?(field)
             edges_resolver = field.metadata[:resolve_edges]
             nodes_resolver = field.metadata[:resolve_nodes]
           else
             # Use the edges and nodes symbols from the incldues pattern as the propeties to fetch
-            edges_resolver = ->(obj, args, ctx) { obj.public_send(edges_prop) }
-            nodes_resolver = ->(obj, args, ctx) { obj.public_send(nodes_prop) }
+            edges_resolver = ->(obj, _args, _ctx) { obj.public_send(edges_prop) }
+            nodes_resolver = ->(obj, _args, _ctx) { obj.public_send(nodes_prop) }
           end
 
           _original_resolve = field.resolve_proc
           new_resolve_proc = ->(obj, args, ctx) do
-            ConnectionEdgesAndNodes.new(obj, args, ctx, edges_prop, nodes_prop, edge_to_node_property, edges_resolver, nodes_resolver)
+            ConnectionEdgesAndNodes.new(obj, args, ctx,
+                                        edges_prop, nodes_prop, edge_to_node_property,
+                                        edges_resolver, nodes_resolver)
           end
 
           field.redefine { resolve(new_resolve_proc) }
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
-        def is_edge_with_node_connection?(field)
+        def edge_with_node_connection?(field)
           field.connection? && field.type.fields['edges'].metadata.key?(:_includable_connection_marker)
         end
 
-        def is_proc_based?(field)
+        def proc_based?(field)
           required_metadata = [:resolve_edges, :resolve_nodes]
           has_a_resolver = required_metadata.any? { |key| field.metadata.key?(key) }
 
           return false unless has_a_resolver
-          raise ArgumentError.new("Missing one of #{required_metadata}") unless required_metadata.all? { |key| field.metadata.key?(key) }
+          unless required_metadata.all? { |key| field.metadata.key?(key) }
+            raise ArgumentError, "Missing one of #{required_metadata}"
+          end
 
           true
         end
 
+        # rubocop:disable Metrics/AbcSize
         def validate!(field)
-          raise ArgumentError.new('Missing edge_to_node_property definition for field') unless field.metadata.key?(:edge_to_node_property)
-          raise ArgumentError.new(':edge_to_node_property must be a symbol') unless field.metadata[:edge_to_node_property].is_a?(Symbol)
+          unless field.metadata.key?(:edge_to_node_property)
+            raise ArgumentError, 'Missing edge_to_node_property definition for field'
+          end
+          unless field.metadata[:edge_to_node_property].is_a?(Symbol)
+            raise ArgumentError, ':edge_to_node_property must be a symbol'
+          end
 
-          raise ArgumentError.new('Missing includes definition for field') unless field.metadata.key?(:includes)
+          raise ArgumentError, 'Missing includes definition for field' unless field.metadata.key?(:includes)
           includes = field.metadata[:includes]
-          raise ArgumentError.new('Connection includes must be a hash containing :edges and :nodes keys') unless includes.is_a?(Hash)
-          raise ArgumentError.new('Missing :nodes includes') unless includes.key?(:nodes)
-          raise ArgumentError.new('Missing :edges includes') unless includes.key?(:edges)
-          raise ArgumentError.new(':edges must be a symbol') unless includes[:edges].is_a?(Symbol)
-          raise ArgumentError.new(':nodes must be a symbol') unless includes[:edges].is_a?(Symbol)
+          unless includes.is_a?(Hash)
+            raise ArgumentError, 'Connection includes must be a hash containing :edges and :nodes keys'
+          end
+          raise ArgumentError, 'Missing :nodes includes' unless includes.key?(:nodes)
+          raise ArgumentError, 'Missing :edges includes' unless includes.key?(:edges)
+          raise ArgumentError, ':edges must be a symbol' unless includes[:edges].is_a?(Symbol)
+          raise ArgumentError, ':nodes must be a symbol' unless includes[:edges].is_a?(Symbol)
         end
+        # rubocop:enable Metrics/AbcSize
       end
 
-      GraphQL::Relay::BaseConnection.register_connection_implementation(GraphQLIncludable::Relay::ConnectionEdgesAndNodes, GraphQLIncludable::Relay::EdgeWithNodeConnection)
+      GraphQL::Relay::BaseConnection.register_connection_implementation(
+        GraphQLIncludable::Relay::ConnectionEdgesAndNodes,
+        GraphQLIncludable::Relay::EdgeWithNodeConnection
+      )
     end
-
   end
 end

data/lib/graphql_includable/resolver.rb

@@ -35,7 +35,7 @@ module GraphQLIncludable
 
       if child_includes_arr.present?
         child_includes_arr << child_includes if child_includes.present?
-        child_includes =  child_includes_arr
+        child_includes = child_includes_arr
       end
 
       return child_includes if @parent_attribute.nil?
@@ -48,16 +48,16 @@ module GraphQLIncludable
     def self.find_node_by_return_type(node, desired_return_type)
       return_type = node.return_type.unwrap.to_s
       return node if return_type == desired_return_type
-      if node.respond_to?(:scoped_children)
-        matching_node = nil
-        node.scoped_children.values.each do |selections|
-          matching_node = selections.values.find do |child_node|
-            find_node_by_return_type(child_node, desired_return_type)
-          end
-          break if matching_node
+      return nil unless node.respond_to?(:scoped_children)
+
+      matching_node = nil
+      node.scoped_children.values.each do |selections|
+        matching_node = selections.values.find do |child_node|
+          find_node_by_return_type(child_node, desired_return_type)
         end
-        matching_node
+        break if matching_node
       end
+      matching_node
     end
 
     # Translate a node's selections into `includes` values
@@ -74,8 +74,11 @@ module GraphQLIncludable
       end
     end
 
-    def self.includes_from_connection(node, parent_model, associations_from_parent_model, includes_manager)
-      return unless node.return_type.fields['edges'].edge_class <= GraphQLIncludable::Relay::EdgeWithNode  # TODO: Possibly basic support for connections with only nodes
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def self.includes_from_connection(node, _parent_model, associations_from_parent_model, includes_manager)
+      # TODO: Possibly basic support for connections with only nodes
+      return unless node.return_type.fields['edges'].edge_class <= GraphQLIncludable::Relay::EdgeWithNode
 
       edges_association = associations_from_parent_model[:edges]
       nodes_association = associations_from_parent_model[:nodes]
@@ -128,21 +131,23 @@ module GraphQLIncludable
         end
       end
     end
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/AbcSize
 
     def self.includes_for_child(node, parent_model, includes_manager)
       associations = possible_associations(node, parent_model)
+      return unless associations.present?
 
-      if associations.present?
-        if node_is_relay_connection?(node)
-          includes_from_connection(node, parent_model, associations, includes_manager)
-        else
-          association = associations[:default] # should only be one
-          child_includes_manager = includes_manager.add_child_include(association)
-          includes_for_node(node, child_includes_manager)
-        end
+      if node_is_relay_connection?(node)
+        includes_from_connection(node, parent_model, associations, includes_manager)
+      else
+        association = associations[:default] # should only be one
+        child_includes_manager = includes_manager.add_child_include(association)
+        includes_for_node(node, child_includes_manager)
       end
     end
 
+    # rubocop:disable Lint/HandleExceptions
     def self.model_name_to_class(model_name)
       begin
         model_name.to_s.camelize.constantize
@@ -158,6 +163,7 @@ module GraphQLIncludable
       model if model < ActiveRecord::Base
     rescue NameError
     end
+    # rubocop:enable Lint/HandleExceptions
 
     def self.node_is_relay_connection?(node)
       node.return_type.unwrap.name =~ /Connection$/

data/lib/graphql_includable.rb

@@ -13,13 +13,13 @@ GraphQL::Field.accepts_definitions(
   resolve_edges: GraphQL::Define.assign_metadata_key(:resolve_edges),
   resolve_nodes: GraphQL::Define.assign_metadata_key(:resolve_nodes),
   # Internal use
-  _includable_connection_marker: GraphQL::Define.assign_metadata_key(:_includable_connection_marker),
+  _includable_connection_marker: GraphQL::Define.assign_metadata_key(:_includable_connection_marker)
 )
 
 module GraphQL
   class BaseType
     def define_includable_connection(**kwargs, &block)
-      warn '[DEPRECATION] `define_includable_connection` is deprecated.  Please use `define_connection_with_fetched_edge` instead.'
+      warn '[DEPRECATION] `define_includable_connection` is deprecated. Use `define_connection_with_fetched_edge`.'
       define_connection(
         edge_class: GraphQLIncludable::Edge,
         **kwargs,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graphql_includable
 version: !ruby/object:Gem::Version
-  version: 0.4.0.alpha.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Dan Rouse
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-06 00:00:00.000000000 Z
+date: 2019-08-07 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -44,9 +44,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.6.14.1