rubocop-graphql 0.12.2 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d488e2bcf0fac1f61555afb433e26834bc653b88598ba9fd23d58be29db44cc
-  data.tar.gz: 31afb3a28f7cd44f165dcd4bd93aecebf270ccc2af05f50816f171f19c88680d
+  metadata.gz: bf7d97ba00fa1e49f43e15e6dd5ee134169eedff3603dc2fcad6d85d832529f0
+  data.tar.gz: ea8b222d69f599a1d9b341fadc15306f8a2b2aff17acf2853aa6129a45bdc056
 SHA512:
-  metadata.gz: a5d35e978439e99de72eb4d90088b6a726bfbf78a6303ce422bfb09a05b4d965e7a28acb06ada12538dea8148f691384a48682ad651cc39d631e779d41098cfb
-  data.tar.gz: 44ca6c9891b4184b6ab40b1a4be8d9398fb94276502a603f09639bf5993c553aee01f845e61a119470f1a7eb5f51659db7114bf47a472c41394649b91fc20c28
+  metadata.gz: dc4926760bca79b7a6ea7f3cb73b3b035d52b7cdc2a3819a76aefaadf28b11aef232ee6fed961301cdc65467592effa0d02217d6fdbf8c91bf703688b5834f31
+  data.tar.gz: 6b3bb0304272b6c6ec0b793f698f9139d53da73bbdf2038ab26d4734c754f5b098e075fcf354c361c71f1e82bdaf3be358be1c9b85065d631e5e54fa89b978a1

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/ordered_arguments.rb

@@ -57,7 +57,19 @@ module RuboCop
               "Field `%<current>s` should appear before `%<previous>s`."
 
         def on_class(node)
-          argument_declarations(node).each_cons(2) do |previous, current|
+          declarations_with_blocks = argument_declarations_with_blocks(node)
+          declarations_without_blocks = argument_declarations_without_blocks(node)
+
+          argument_declarations = declarations_without_blocks.map do |node|
+            arg_name = argument_name(node)
+            same_arg_with_block_declaration = declarations_with_blocks.find do |dec|
+              argument_name(dec) == arg_name
+            end
+
+            same_arg_with_block_declaration || node
+          end
+
+          argument_declarations.each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)
             next if argument_name(current) >= argument_name(previous)
 
@@ -80,16 +92,26 @@ module RuboCop
         end
 
         def argument_name(node)
-          node.first_argument.value.to_s
+          argument = node.block_type? ? node.children.first.first_argument : node.first_argument
+
+          argument.value.to_s
         end
 
         def consecutive_lines(previous, current)
           previous.source_range.last_line == current.source_range.first_line - 1
         end
 
-        def_node_search :argument_declarations, <<~PATTERN
+        def_node_search :argument_declarations_without_blocks, <<~PATTERN
           (send nil? :argument (:sym _) ...)
         PATTERN
+
+        def_node_search :argument_declarations_with_blocks, <<~PATTERN
+          (block
+            (send nil? :argument
+              (:sym _)
+              ...)
+            ...)
+        PATTERN
       end
     end
   end

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

@@ -72,7 +72,7 @@ module RuboCop
                       arg.arg_type? || arg.kwrestarg_type?
                     end
 
-          declared_arg_nodes = argument_declarations(node)
+          declared_arg_nodes = find_declared_arg_nodes(node)
           return unless declared_arg_nodes.any?
 
           unresolved_args = find_unresolved_args(resolve_method_node, declared_arg_nodes)
@@ -81,9 +81,19 @@ module RuboCop
 
         private
 
+        def find_declared_arg_nodes(node)
+          argument_declarations(node).select do |arg_declaration|
+            # argument is declared on the same class that is being analyzed
+            arg_declaration.each_ancestor(:class).first == node
+          end
+        end
+
         def find_resolve_method_node(node)
           resolve_method_nodes = resolve_method_definition(node)
-          resolve_method_nodes.to_a.last if resolve_method_nodes.any?
+          resolve_method_nodes.find do |resolve_node|
+            # reject resolve methods from other classes
+            resolve_node.each_ancestor(:class).first == node
+          end
         end
 
         def find_unresolved_args(method_node, declared_arg_nodes)

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/node_uniqueness.rb

@@ -7,10 +7,6 @@ module RuboCop
       def current_class_full_name(node)
         node.each_ancestor(:class).map(&:defined_module_name).join("::")
       end
-
-      def nested_class?(node)
-        node.each_ancestor(:class).any?
-      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.12.2".freeze
+    VERSION = "0.14.0".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.12.2
+  version: 0.14.0
 platform: ruby
 authors:
 - Dmitry Tsepelev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-07 00:00:00.000000000 Z
+date: 2022-03-23 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: []