rubocop-graphql 0.13.0 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d809ed60d2d98c5f7f84a3555d8ad24ad2c2e1ece6a5fed616b6698260981d29
-  data.tar.gz: e62936fc399419ee72070e658be32660763a96144776727e183007aa53ad0bd8
+  metadata.gz: d8c5edb3e37ffc8245916608bb37f79dc28afb39dde464477e5b31e7f92aef59
+  data.tar.gz: 3fc868fb4e1ee8cdb0fed44c35ae98899e83eb605e0618faba161f65344554b4
 SHA512:
-  metadata.gz: 8c508f31ceb2e6f1290ef0220896019c5f3ff007dbd2ec651ba44ad5cc422680ec761ccb6739a7e90f243cc434b787f849d872143c6e709967deeeb81e6500ec
-  data.tar.gz: ccd1741a8b20403f5a904aa321526fb089f4af357b1a8cce37547221f11ef1fa4f407169aedb35923b85c4b5dc5eb0bba76f74ce7b585b260a0d90549c2d7dfb
+  metadata.gz: 96f21cb69d2a7fc4c5c084e4859756fc7f525fc29e5c7c2dd4bf5fb1233d039ff3932d5783cdd10f91b0cee15c5cc8c91e94e3fec2f07ee0d09fdbc4b32e2799
+  data.tar.gz: c88d409a7c67630c3f68d98fb6d78418be4c3c99d601470f9732ed456b4ee86f3f2439323c019b82eaa52f2b613aa01fdf14cc195304eb3fc0a7c6bb3bec6774

data/lib/rubocop/cop/graphql/field_definitions.rb

@@ -44,11 +44,13 @@ module RuboCop
       #       object.contact_data.last_name
       #     end
       #   end
-      class FieldDefinitions < Base
+      class FieldDefinitions < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
         include ConfigurableEnforcedStyle
         include RuboCop::GraphQL::NodePattern
         include RuboCop::Cop::RangeHelp
+        include RuboCop::GraphQL::Sorbet
+        include RuboCop::GraphQL::Heredoc
 
         def_node_matcher :field_kwargs, <<~PATTERN
           (send nil? :field
@@ -101,14 +103,14 @@ module RuboCop
             field_definition?(node) || field_definition_with_body?(node)
           end
 
-          source_to_insert = "\n#{indent(node)}#{node.source}"
-          corrector.insert_after(first_field.loc.expression, source_to_insert)
+          insert_new_resolver(corrector, first_field, node)
 
-          range = range_with_surrounding_space(range: node.loc.expression, side: :left)
-          corrector.remove(range)
+          remove_old_resolver(corrector, node)
         end
 
         RESOLVER_AFTER_FIELD_MSG = "Define resolver method after field definition."
+        RESOLVER_AFTER_LAST_FIELD_MSG = "Define resolver method after last field definition " \
+          "sharing resolver method."
 
         def check_resolver_is_defined_after_definition(field)
           return if field.kwargs.resolver || field.kwargs.method || field.kwargs.hash_key
@@ -116,6 +118,22 @@ module RuboCop
           method_definition = field.schema_member.find_method_definition(field.resolver_method_name)
           return unless method_definition
 
+          fields_with_same_resolver = fields_with_same_resolver(field, method_definition)
+          return unless field.name == fields_with_same_resolver.last.name
+
+          return if resolver_defined_after_definition?(field, method_definition)
+
+          add_offense(field.node,
+                      message: offense_message(fields_with_same_resolver.one?)) do |corrector|
+            place_resolver_after_field_definition(corrector, field.node)
+          end
+        end
+
+        def offense_message(single_field_using_resolver)
+          single_field_using_resolver ? RESOLVER_AFTER_FIELD_MSG : RESOLVER_AFTER_LAST_FIELD_MSG
+        end
+
+        def resolver_defined_after_definition?(field, method_definition)
           field_sibling_index =
             if field_definition_with_body?(field.parent)
               field.parent.sibling_index
@@ -123,28 +141,80 @@ module RuboCop
               field.sibling_index
             end
 
-          return if method_definition.sibling_index - field_sibling_index == 1
+          field_to_resolver_offset = method_definition.sibling_index - field_sibling_index
 
-          add_offense(field.node, message: RESOLVER_AFTER_FIELD_MSG) do |corrector|
-            place_resolver_after_definitions(corrector, field.node)
+          case field_to_resolver_offset
+          when 1 # resolver is immediately after field definition
+            return true
+          when 2 # there is a node between the field definition and its resolver
+            return true if has_sorbet_signature?(method_definition)
           end
+
+          false
         end
 
-        def place_resolver_after_definitions(corrector, node)
+        def fields_with_same_resolver(field, resolver)
+          fields = field.schema_member.body
+                        .select { |node| field?(node) }
+                        .map do |node|
+                          field = field_definition_with_body?(node) ? node.children.first : node
+                          RuboCop::GraphQL::Field.new(field)
+                        end
+
+          [].tap do |fields_with_same_resolver|
+            fields.each do |field|
+              return [field] if field.name == resolver.method_name
+              next if field.kwargs.resolver_method_name != resolver.method_name
+
+              fields_with_same_resolver << field
+            end
+          end
+        end
+
+        def place_resolver_after_field_definition(corrector, node)
           field = RuboCop::GraphQL::Field.new(node)
 
-          method_definition = field.schema_member.find_method_definition(field.resolver_method_name)
+          resolver_method_name = field.resolver_method_name
+          resolver_definition = field.schema_member.find_method_definition(resolver_method_name)
 
           field_definition = field_definition_with_body?(node.parent) ? node.parent : node
 
-          source_to_insert = "#{indent(method_definition)}#{field_definition.source}\n\n"
-          method_range = range_by_whole_lines(method_definition.loc.expression)
-          corrector.insert_before(method_range, source_to_insert)
+          insert_new_resolver(corrector, field_definition, resolver_definition)
 
+          remove_old_resolver(corrector, resolver_definition)
+        end
+
+        def insert_new_resolver(corrector, field_definition, resolver_definition)
+          source_to_insert =
+            "\n#{signature_to_insert(resolver_definition)}\n" \
+              "#{indent(resolver_definition)}#{resolver_definition.source}\n"
+
+          field_definition_range = range_including_heredoc(field_definition)
+          corrector.insert_after(field_definition_range, source_to_insert)
+        end
+
+        def remove_old_resolver(corrector, resolver_definition)
           range_to_remove = range_with_surrounding_space(
-            range: field_definition.loc.expression, side: :left
+            range: resolver_definition.loc.expression, side: :left
           )
           corrector.remove(range_to_remove)
+
+          resolver_signature = sorbet_signature_for(resolver_definition)
+
+          return unless resolver_signature
+
+          range_to_remove = range_with_surrounding_space(
+            range: resolver_signature.loc.expression, side: :left
+          )
+          corrector.remove(range_to_remove)
+        end
+
+        def signature_to_insert(node)
+          signature = sorbet_signature_for(node)
+
+          return unless signature
+
+          "\n#{indent(signature)}#{signature.source}"
         end
 
         def indent(node)

data/lib/rubocop/cop/graphql/field_hash_key.rb

@@ -47,10 +47,13 @@ module RuboCop
           field = RuboCop::GraphQL::Field.new(node)
           method_definition = resolver_method_definition_for(field)
 
-          if (suggested_hash_key_name = hash_key_to_use(method_definition))
-            add_offense(node, message: message(suggested_hash_key_name)) do |corrector|
-              autocorrect(corrector, node)
-            end
+          suggested_hash_key_name = hash_key_to_use(method_definition)
+
+          return if suggested_hash_key_name.nil?
+          return if RuboCop::GraphQL::Field::CONFLICT_FIELD_NAMES.include?(suggested_hash_key_name)
+
+          add_offense(node, message: message(suggested_hash_key_name)) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 

data/lib/rubocop/cop/graphql/field_method.rb

@@ -46,10 +46,13 @@ module RuboCop
           field = RuboCop::GraphQL::Field.new(node)
           method_definition = suggest_method_name_for(field)
 
-          if (suggested_method_name = method_to_use(method_definition))
-            add_offense(node, message: message(suggested_method_name)) do |corrector|
-              autocorrect(corrector, node)
-            end
+          suggested_method_name = method_to_use(method_definition)
+
+          return if suggested_method_name.nil?
+          return if RuboCop::GraphQL::Field::CONFLICT_FIELD_NAMES.include?(suggested_method_name)
+
+          add_offense(node, message: message(suggested_method_name)) do |corrector|
+            autocorrect(corrector, node)
           end
         end
 

data/lib/rubocop/cop/graphql/object_description.rb

@@ -52,7 +52,7 @@ module RuboCop
 
         def has_description?(node)
           has_i18n_description?(node) ||
-            description_kwarg?(node)
+            description_method_call?(node)
         end
 
         def child_nodes(node)

data/lib/rubocop/cop/graphql/unused_argument.rb

@@ -67,10 +67,7 @@ module RuboCop
 
         def on_class(node)
           resolve_method_node = find_resolve_method_node(node)
-          return if resolve_method_node.nil? ||
-                    resolve_method_node.arguments.any? do |arg|
-                      arg.arg_type? || arg.kwrestarg_type?
-                    end
+          return if resolve_method_node.nil? || ignore_arguments_type?(resolve_method_node)
 
           declared_arg_nodes = find_declared_arg_nodes(node)
           return unless declared_arg_nodes.any?
@@ -109,6 +106,12 @@ module RuboCop
           end
         end
 
+        def ignore_arguments_type?(resolve_method_node)
+          resolve_method_node.arguments.any? do |arg|
+            arg.arg_type? || arg.kwrestarg_type? || arg.forward_arg_type?
+          end
+        end
+
         def register_offense(node, unresolved_args)
           unresolved_args_source = unresolved_args.map { |v| "#{v}:" }.join(", ")
 

data/lib/rubocop/graphql/argument/block.rb

@@ -10,7 +10,7 @@ module RuboCop
         def_node_matcher :argument_block, <<~PATTERN
           (block
             (send nil? :argument ...)
-            (args)
+            (args ...)
             $...
           )
         PATTERN

data/lib/rubocop/graphql/description_method.rb

@@ -20,13 +20,18 @@ module RuboCop
     module DescriptionMethod
       extend RuboCop::NodePattern::Macros
 
-      def_node_matcher :description_kwarg?, <<~PATTERN
-        (send nil? :description
-          {({str|dstr|const} ...)|(send const ...)|(send ({str|dstr} ...) _)})
+      DESCRIPTION_STRING = "{({str|dstr|const} ...)|(send const ...)|(send ({str|dstr} ...) _)}"
+
+      def_node_matcher :description_method_call?, <<~PATTERN
+        (send nil? :description #{DESCRIPTION_STRING})
+      PATTERN
+
+      def_node_matcher :description_with_block_arg?, <<~PATTERN
+        (send (lvar _) {:description= :description} #{DESCRIPTION_STRING})
       PATTERN
 
       def find_description_method(nodes)
-        nodes.find { |kwarg| description_kwarg?(kwarg) }
+        nodes.find { |kwarg| description_method_call?(kwarg) || description_with_block_arg?(kwarg) }
       end
     end
   end

data/lib/rubocop/graphql/field/block.rb

@@ -10,7 +10,7 @@ module RuboCop
         def_node_matcher :field_block, <<~PATTERN
           (block
             (send nil? :field ...)
-            (args)
+            (args ...)
             {(begin $...)|$...}
           )
         PATTERN

data/lib/rubocop/graphql/field.rb

@@ -6,6 +6,18 @@ module RuboCop
       extend Forwardable
       extend RuboCop::NodePattern::Macros
 
+      # These constants were extracted from graphql-ruby in lib/graphql/schema/member/has_fields.rb
+      RUBY_KEYWORDS = %i[class module def undef begin rescue ensure end if unless then elsif else
+                         case when while until for break next redo retry in do return yield super
+                         self nil true false and or not alias defined? BEGIN END __LINE__
+                         __FILE__].freeze
+
+      GRAPHQL_RUBY_KEYWORDS = %i[context object raw_value].freeze
+
+      CONFLICT_FIELD_NAMES = Set.new(
+        GRAPHQL_RUBY_KEYWORDS + RUBY_KEYWORDS + Object.instance_methods
+      )
+
       def_delegators :@node, :sibling_index, :parent
 
       def_node_matcher :field_name, <<~PATTERN

data/lib/rubocop/graphql/heredoc.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    module Heredoc
+      def heredoc?(node)
+        (node.str_type? || node.dstr_type?) && node.heredoc?
+      end
+
+      def range_including_heredoc(node)
+        field = RuboCop::GraphQL::Field.new(node)
+        last_heredoc = field.kwargs.instance_variable_get(:@nodes).reverse.find do |kwarg|
+                         heredoc?(kwarg.value)
+                       end&.value
+
+        range = node.loc.expression
+        range = range.join(last_heredoc.loc.heredoc_end) if last_heredoc
+
+        range_by_whole_lines(range)
+      end
+    end
+  end
+end

data/lib/rubocop/graphql/sorbet.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    module Sorbet
+      extend RuboCop::NodePattern::Macros
+
+      def_node_matcher(:sorbet_signature, <<~PATTERN)
+        (block (send nil? :sig) (args) ...)
+      PATTERN
+
+      def has_sorbet_signature?(node)
+        !!sorbet_signature_for(node)
+      end
+
+      def sorbet_signature_for(node)
+        node.parent.each_descendant.find do |sibling|
+          siblings_in_sequence?(sibling, node) &&
+            sorbet_signature(sibling)
+        end
+      end
+
+      private
+
+      def siblings_in_sequence?(first_node, second_node)
+        first_node.sibling_index - second_node.sibling_index == - 1
+      end
+    end
+  end
+end

data/lib/rubocop/graphql/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module GraphQL
-    VERSION = "0.13.0".freeze
+    VERSION = "0.14.2".freeze
   end
 end

data/lib/rubocop-graphql.rb

@@ -8,8 +8,10 @@ require_relative "rubocop/graphql"
 require_relative "rubocop/graphql/version"
 require_relative "rubocop/graphql/inject"
 require_relative "rubocop/graphql/description_method"
+require_relative "rubocop/graphql/heredoc"
 require_relative "rubocop/graphql/node_pattern"
 require_relative "rubocop/graphql/node_uniqueness"
+require_relative "rubocop/graphql/sorbet"
 require_relative "rubocop/graphql/swap_range"
 
 require_relative "rubocop/graphql/argument"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-graphql
 version: !ruby/object:Gem::Version
-  version: 0.13.0
+  version: 0.14.2
 platform: ruby
 authors:
 - Dmitry Tsepelev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-11 00:00:00.000000000 Z
+date: 2022-03-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -112,10 +112,12 @@ files:
 - lib/rubocop/graphql/field.rb
 - lib/rubocop/graphql/field/block.rb
 - lib/rubocop/graphql/field/kwargs.rb
+- lib/rubocop/graphql/heredoc.rb
 - lib/rubocop/graphql/inject.rb
 - lib/rubocop/graphql/node_pattern.rb
 - lib/rubocop/graphql/node_uniqueness.rb
 - lib/rubocop/graphql/schema_member.rb
+- lib/rubocop/graphql/sorbet.rb
 - lib/rubocop/graphql/swap_range.rb
 - lib/rubocop/graphql/version.rb
 homepage: https://github.com/DmitryTsepelev/rubocop-graphql
@@ -125,7 +127,7 @@ metadata:
   homepage_uri: https://github.com/DmitryTsepelev/rubocop-graphql
   source_code_uri: https://github.com/DmitryTsepelev/rubocop-graphql
   changelog_uri: https://github.com/DmitryTsepelev/rubocop-graphql/blob/master/CHANGELOG.md
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -140,8 +142,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Automatic performance checking tool for Ruby code.
 test_files: []