rubocop-graphql 0.1.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30e4dfa482d073cf52c315042d736a54ce725491b3dcf130c9fecd3987bed8d2
-  data.tar.gz: 4e2467eab2c0ae0be138f6acf3b21912ad888c7b3cbcad98c2c7b0da3d9579af
+  metadata.gz: 5be7099abfc014351e097467d9dfe7c687d4a0323241f7ce592e0abe25f6b0cb
+  data.tar.gz: da4e69f7810f416873d3f3f0742b70758a3c66c343bbd0d2572c223605156c77
 SHA512:
-  metadata.gz: 6099e724a272914bac6212d07ad92256316db2874b26edcd2daf9e8155668f5ddb6b394221b740e8ed51273b49eb101cd83cba55c59352a6c2cd178e972afb9b
-  data.tar.gz: 80f3d7cfa9e10f209e3f8d2cbf373ac370dc738da62e05b704f37cb8aaccd41216aed6294f063092d26c606645877b3bc0c2aba77bfabf6b5590b79d31e6928f
+  metadata.gz: ea0737a86c403dbd57b5777c221ce80ec86e97c6fce499d00f573ef7adeb15f37e2db7b2c8f6275ff7aa58e1a17b12472a748cdf06f26c0411cb9943075386fd
+  data.tar.gz: c0b0235d1035b9b77ffaaac3ee419b4e240c9eb7363033f37f9396a028930e33f6d11d3145f95c708e68a0b2f7566de0e1cf96264619eb1da0c3626e99304a0b

data/README.md

@@ -1,4 +1,4 @@
-# Rubocop::GraphQL
+# RuboCop::GraphQL
 
 [Rubocop](https://github.com/rubocop-hq/rubocop) extension for enforcing [graphql-ruby](https://github.com/rmosolgo/graphql-ruby) best practices.
 
@@ -24,7 +24,7 @@ gem 'rubocop-graphql', require: false
 
 ## Usage
 
-You need to tell RuboCop to load the Rails extension. There are three ways to do this:
+You need to tell RuboCop to load the GraphQL extension. There are three ways to do this:
 
 ### RuboCop configuration file
 
@@ -42,7 +42,7 @@ require:
   - rubocop-graphql
 ```
 
-Now you can run `rubocop` and it will automatically load the RuboCop Rails cops together with the standard cops.
+Now you can run `rubocop` and it will automatically load the RuboCop GraphQL cops together with the standard cops.
 
 ### Command line
 
@@ -62,7 +62,7 @@ end
 
 All cops are located under [`lib/rubocop/cop/graphql`](lib/rubocop/cop/graphql), and contain examples and documentation.
 
-In your `.rubocop.yml`, you may treat the Rails cops just like any other cop. For example:
+In your `.rubocop.yml`, you may treat the GraphQL cops just like any other cop. For example:
 
 ```yaml
 GraphQL/ResolverMethodLength:

data/config/default.yml

@@ -3,10 +3,20 @@ AllCops:
     Patterns:
       - "(?:^|/)graphql/"
 
+GraphQL/ArgumentDescription:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'Ensures all arguments have a description'
+
+GraphQL/ArgumentName:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'This cop checks whether argument names are snake_case'
+
 GraphQL/ResolverMethodLength:
   Enabled: true
   VersionAdded: '0.80'
-  Description: 'Avoid resolver methods longer than 10 lines of code.'
+  Description: 'Checks resolver methods are not too long'
   Max: 10
   CountComments: false
   ExcludedMethods: []
@@ -23,4 +33,45 @@ GraphQL/FieldDefinitions:
 GraphQL/FieldDescription:
   Enabled: true
   VersionAdded: '0.80'
-  Description: 'Missing field description'
+  Description: 'Ensures all fields have a description'
+
+GraphQL/FieldHashKey:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'Checks :hash_key option is used for appropriate fields'
+
+GraphQL/FieldMethod:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'Checks :method option is used for appropriate fields'
+
+GraphQL/FieldName:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'This cop checks whether field names are snake_case'
+
+GraphQL/ExtractInputType:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'Suggests using input type instead of many arguments'
+  MaxArguments: 2
+
+GraphQL/ExtractType:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'Suggests extracting fields with common prefixes to the separate type'
+  MaxFields: 2
+  Prefixes:
+    - is
+    - with
+    - avg
+    - min
+    - max
+
+GraphQL/ObjectDescription:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'Ensures all types have a description'
+  Exclude:
+    - '**/*_schema.rb'
+    - '**/base_*.rb'

data/lib/rubocop-graphql.rb

@@ -2,11 +2,20 @@
 
 require "rubocop"
 
+require_relative "rubocop/graphql/ext/snake_case"
+
 require_relative "rubocop/graphql"
 require_relative "rubocop/graphql/version"
 require_relative "rubocop/graphql/inject"
 require_relative "rubocop/graphql/node_pattern"
+
+require_relative "rubocop/graphql/argument"
+require_relative "rubocop/graphql/argument/block"
+require_relative "rubocop/graphql/argument/kwargs"
 require_relative "rubocop/graphql/field"
+require_relative "rubocop/graphql/field/block"
+require_relative "rubocop/graphql/field/kwargs"
+require_relative "rubocop/graphql/schema_member"
 
 RuboCop::GraphQL::Inject.defaults!
 

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      #  This cop checks if each field has a description.
+      #
+      # @example
+      #   # good
+      #
+      #   class BanUser < BaseMutation
+      #     argument :uuid, ID, required: true, description: "UUID of the user to ban"
+      #   end
+      #
+      #   # bad
+      #
+      #   class BanUser < BaseMutation
+      #     argument :uuid, ID, required: true
+      #   end
+      #
+      class ArgumentDescription < Cop
+        include RuboCop::GraphQL::NodePattern
+
+        MSG = "Missing argument description"
+
+        def on_send(node)
+          return unless argument?(node)
+
+          argument = RuboCop::GraphQL::Argument.new(node)
+
+          add_offense(node) unless argument.description
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      #  This cop checks whether field names are snake_case.
+      #
+      # @example
+      #   # good
+      #
+      #   class BanUser < BaseMutation
+      #     argument :user_id, ID, required: true
+      #   end
+      #
+      #   # bad
+      #
+      #   class BanUser < BaseMutation
+      #     argument :userId, ID, required: true
+      #   end
+      #
+      class ArgumentName < Cop
+        include RuboCop::GraphQL::NodePattern
+
+        using RuboCop::GraphQL::Ext::SnakeCase
+
+        MSG = "Use snake_case for argument names"
+
+        def on_send(node)
+          return unless argument?(node)
+
+          argument = RuboCop::GraphQL::Argument.new(node)
+          return if argument.name.snake_case?
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      class ExtractInputType < Cop
+        # This cop checks fields on common prefix groups
+        #
+        # # @example
+        #   # good
+        #
+        #   class UpdateUser < BaseMutation
+        #     argument :uuid, ID, required: true
+        #     argument :user_attributes, UserAttributesInputType
+        #   end
+        #
+        #   # bad
+        #
+        #   class UpdateUser < BaseMutation
+        #     argument :uuid, ID, required: true
+        #     argument :first_name, String, required: true
+        #     argument :last_name, String, required: true
+        #   end
+        #
+        include RuboCop::GraphQL::NodePattern
+
+        MSG = "Consider moving arguments to a new input type"
+
+        def on_class(node)
+          schema_member = RuboCop::GraphQL::SchemaMember.new(node)
+
+          if (body = schema_member.body)
+            arguments = body.select { |node| argument?(node) }
+
+            add_offense(arguments.last) if arguments.count > cop_config["MaxArguments"]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      class ExtractType < Cop
+        # This cop checks fields on common prefix groups
+        #
+        # # @example
+        #   # good
+        #
+        #   class Types::UserType < Types::BaseObject
+        #     field :registered_at, String, null: false
+        #     field :contact, Types::ContactType, null: false
+        #
+        #     def contact
+        #       self
+        #     end
+        #   end
+        #
+        #   class Types::ContactType < Types::BaseObject
+        #     field :phone, String, null: false
+        #     field :first_name, String, null: false
+        #     field :last_name, String, null: false
+        #   end
+        #
+        #   # bad
+        #
+        #   class Types::UserType < Types::BaseObject
+        #     field :registered_at, String, null: false
+        #     field :contact_phone, String, null: false
+        #     field :contact_first_name, String, null: false
+        #     field :contact_last_name, String, null: false
+        #   end
+        #
+        include RuboCop::GraphQL::NodePattern
+
+        def on_class(node)
+          schema_member = RuboCop::GraphQL::SchemaMember.new(node)
+
+          if (body = schema_member.body)
+            check_fields_prefixes(body)
+          end
+        end
+
+        private
+
+        MSG = "Consider moving %<field_names>s to a new type and adding the `%<prefix>s` field instead"
+
+        def check_fields_prefixes(body)
+          sorted_prefixes = fractured(body).sort_by { |k, _| k.size }.reverse
+          already_offenced_fields = []
+
+          sorted_prefixes.each do |prefix, fields|
+            fields -= already_offenced_fields
+
+            next if fields.count < cop_config["MaxFields"]
+
+            add_offense(
+              fields.last.node,
+              message: message(prefix, fields.map(&:name).join(", "))
+            )
+
+            already_offenced_fields += fields
+          end
+        end
+
+        def fractured(body)
+          body.each_with_object({}) do |node, acc|
+            next unless field?(node)
+
+            field = RuboCop::GraphQL::Field.new(node)
+            next unless field.underscore_name.include?("_")
+
+            *prefixes, _ = field.underscore_name.split("_")
+
+            prefixes.each_with_object([]) do |prefix, prev_prefix|
+              prefix = (prev_prefix + [prefix]).join("_")
+              break if ignored_prefix?(prefix)
+
+              (acc[prefix] ||= []) << field
+
+              prev_prefix << prefix
+            end
+          end
+        end
+
+        def message(prefix, field_names)
+          format(MSG, field_names: field_names, prefix: prefix)
+        end
+
+        def ignored_prefix?(word)
+          cop_config["Prefixes"].include?(word)
+        end
+      end
+    end
+  end
+end

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

@@ -47,6 +47,7 @@ module RuboCop
       class FieldDefinitions < Cop
         include ConfigurableEnforcedStyle
         include RuboCop::GraphQL::NodePattern
+        include RuboCop::Cop::RangeHelp
 
         def_node_matcher :field_kwargs, <<~PATTERN
           (send nil? :field
@@ -57,10 +58,6 @@ module RuboCop
           )
         PATTERN
 
-        def_node_matcher :class_body, <<~PATTERN
-          (class ... (begin $...))
-        PATTERN
-
         def on_send(node)
           return if !field_definition?(node) || style != :define_resolver_after_definition
 
@@ -71,8 +68,22 @@ module RuboCop
         def on_class(node)
           return if style != :group_definitions
 
-          body = class_body(node)
-          check_grouped_field_declarations(body) if body
+          schema_member = RuboCop::GraphQL::SchemaMember.new(node)
+
+          if (body = schema_member.body)
+            check_grouped_field_declarations(body)
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            case style
+            when :define_resolver_after_definition
+              place_resolver_after_definitions(corrector, node)
+            when :group_definitions
+              group_field_declarations(corrector, node)
+            end
+          end
         end
 
         private
@@ -80,7 +91,7 @@ module RuboCop
         GROUP_DEFS_MSG = "Group all field definitions together."
 
         def check_grouped_field_declarations(body)
-          fields = body.select { |node| field_definition?(node) || field_definition_with_body?(node) }
+          fields = body.select { |node| field?(node) }
 
           first_field = fields.first
 
@@ -91,13 +102,26 @@ module RuboCop
           end
         end
 
+        def group_field_declarations(corrector, node)
+          field = RuboCop::GraphQL::Field.new(node)
+
+          first_field = field.schema_member.body.find { |node|
+            field_definition?(node) || field_definition_with_body?(node)
+          }
+
+          source_to_insert = "\n" + indent(node) + node.source
+          corrector.insert_after(first_field.loc.expression, source_to_insert)
+
+          range = range_with_surrounding_space(range: node.loc.expression, side: :left)
+          corrector.remove(range)
+        end
+
         RESOLVER_AFTER_FIELD_MSG = "Define resolver method after field definition."
 
         def check_resolver_is_defined_after_definition(field)
-          return if field.resolver || field.method || field.hash_key
+          return if field.kwargs.resolver || field.kwargs.method || field.kwargs.hash_key
 
-          root = field.ancestors.find { |parent| root_node?(parent) }
-          method_definition = find_method_definition(root, field.resolver_method_name)
+          method_definition = field.schema_member.find_method_definition(field.resolver_method_name)
           return unless method_definition
 
           field_sibling_index = if field_definition_with_body?(field.parent)
@@ -111,16 +135,23 @@ module RuboCop
           add_offense(field.node, message: RESOLVER_AFTER_FIELD_MSG)
         end
 
-        def find_method_definition(root, method_name)
-          class_body(root).find { |node| node.def_type? && node.method_name == method_name }
-        end
+        def place_resolver_after_definitions(corrector, node)
+          field = RuboCop::GraphQL::Field.new(node)
+
+          method_definition = field.schema_member.find_method_definition(field.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)
 
-        def root_node?(node)
-          node.parent.nil? || root_with_siblings?(node.parent)
+          range_to_remove = range_with_surrounding_space(range: field_definition.loc.expression, side: :left)
+          corrector.remove(range_to_remove)
         end
 
-        def root_with_siblings?(node)
-          node.begin_type? && node.parent.nil?
+        def indent(node)
+          " " * node.location.column
         end
       end
     end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      #  This cop prevents defining unnecessary resolver methods in cases
+      #  when :hash_key option can be used
+      #
+      # @example
+      #   # good
+      #
+      #   class Types::UserType < Types::BaseObject
+      #     field :phone, String, null: true, hash_key: :home_phone
+      #   end
+      #
+      #   # bad
+      #
+      #   class Types::UserType < Types::BaseObject
+      #     field :phone, String, null: true
+      #
+      #     def phone
+      #       object[:home_phone]
+      #     end
+      #   end
+      #
+      class FieldHashKey < Cop
+        include RuboCop::GraphQL::NodePattern
+        include RuboCop::Cop::RangeHelp
+
+        def_node_matcher :hash_key_to_use, <<~PATTERN
+          (def
+            _
+            (args)
+            (send
+              (send nil? :object) :[]
+              (_type $_)
+            )
+          )
+        PATTERN
+
+        MSG = "Use hash_key: %<hash_key>p"
+
+        def on_send(node)
+          return unless field_definition?(node)
+
+          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))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            field = RuboCop::GraphQL::Field.new(node)
+            method_definition = resolver_method_definition_for(field)
+            suggested_hash_key_name = hash_key_to_use(method_definition)
+
+            corrector.insert_after(node.loc.expression, ", hash_key: #{suggested_hash_key_name.inspect}")
+
+            range = range_with_surrounding_space(range: method_definition.loc.expression, side: :left)
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def message(hash_key)
+          format(MSG, hash_key: hash_key)
+        end
+
+        def resolver_method_definition_for(field)
+          method_name = field.resolver_method_name
+          field.schema_member.find_method_definition(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      #  This cop prevents defining unnecessary resolver methods in cases
+      #  when :method option can be used
+      #
+      # @example
+      #   # good
+      #
+      #   class Types::UserType < Types::BaseObject
+      #     field :phone, String, null: true, method: :home_phone
+      #   end
+      #
+      #   # bad
+      #
+      #   class Types::UserType < Types::BaseObject
+      #     field :phone, String, null: true
+      #
+      #     def phone
+      #       object.home_phone
+      #     end
+      #   end
+      #
+      class FieldMethod < Cop
+        include RuboCop::GraphQL::NodePattern
+        include RuboCop::Cop::RangeHelp
+
+        def_node_matcher :method_to_use, <<~PATTERN
+          (def
+            _
+            (args)
+            (send
+              (send nil? :object) $_
+            )
+          )
+        PATTERN
+
+        MSG = "Use method: :%<method_name>s"
+
+        def on_send(node)
+          return unless field_definition?(node)
+
+          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))
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            field = RuboCop::GraphQL::Field.new(node)
+            method_definition = suggest_method_name_for(field)
+            suggested_method_name = method_to_use(method_definition)
+
+            corrector.insert_after(node.loc.expression, ", method: :#{suggested_method_name}")
+
+            range = range_with_surrounding_space(range: method_definition.loc.expression, side: :left)
+            corrector.remove(range)
+          end
+        end
+
+        private
+
+        def message(method_name)
+          format(MSG, method_name: method_name)
+        end
+
+        def suggest_method_name_for(field)
+          method_name = field.resolver_method_name
+          field.schema_member.find_method_definition(method_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      #  This cop checks whether field names are snake_case.
+      #
+      # @example
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     field :first_name, String, null: true
+      #   end
+      #
+      #   # bad
+      #
+      #   class UserType < BaseType
+      #     field :firstName, String, null: true
+      #   end
+      #
+      class FieldName < Cop
+        include RuboCop::GraphQL::NodePattern
+
+        using RuboCop::GraphQL::Ext::SnakeCase
+
+        MSG = "Use snake_case for field names"
+
+        def on_send(node)
+          return unless field_definition?(node)
+
+          field = RuboCop::GraphQL::Field.new(node)
+          return if field.name.snake_case?
+
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      #  This cop checks if a type (object, input, interface, scalar, union, mutation, subscription, and resolver) has a description.
+      #
+      # @example
+      #   # good
+      #
+      #   class Types::UserType < Types::BaseObject
+      #     description "Represents application user"
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #
+      #   class Types::UserType < Types::BaseObject
+      #     # ...
+      #   end
+      #
+      class ObjectDescription < Cop
+        include RuboCop::GraphQL::NodePattern
+
+        MSG = "Missing type description"
+
+        def_node_matcher :has_i18n_description?, <<~PATTERN
+          (send nil? :description (send (const nil? :I18n) :t ...))
+        PATTERN
+
+        def_node_matcher :has_string_description?, <<~PATTERN
+          (send nil? :description (:str $_))
+        PATTERN
+
+        def_node_matcher :interface?, <<~PATTERN
+          (send nil? :include (const ...))
+        PATTERN
+
+        def on_class(node)
+          return if child_nodes(node).find { |child_node| has_description?(child_node) }
+
+          add_offense(node.identifier)
+        end
+
+        def on_module(node)
+          return if child_nodes(node).none? { |child_node| interface?(child_node) }
+
+          add_offense(node.identifier) if child_nodes(node).none? { |child_node| has_description?(child_node) }
+        end
+
+        private
+
+        def has_description?(node)
+          has_i18n_description?(node) || has_string_description?(node)
+        end
+
+        def child_nodes(node)
+          if node.body.instance_of? RuboCop::AST::Node
+            node.body.child_nodes
+          else
+            node.child_nodes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/graphql_cops.rb

@@ -2,6 +2,14 @@
 
 require_relative "graphql/cop"
 
+require_relative "graphql/argument_description"
+require_relative "graphql/argument_name"
+require_relative "graphql/extract_input_type"
+require_relative "graphql/extract_type"
 require_relative "graphql/field_definitions"
 require_relative "graphql/field_description"
+require_relative "graphql/field_hash_key"
+require_relative "graphql/field_method"
+require_relative "graphql/field_name"
 require_relative "graphql/resolver_method_length"
+require_relative "graphql/object_description"

data/lib/rubocop/graphql/argument.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    class Argument
+      extend RuboCop::NodePattern::Macros
+
+      def_node_matcher :argument_description, <<~PATTERN
+        (send nil? :argument _ _ (:str $_) ...)
+      PATTERN
+
+      def_node_matcher :argument_name, <<~PATTERN
+        (send nil? :argument (:sym $_) ...)
+      PATTERN
+
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def name
+        @name ||= argument_name(@node)
+      end
+
+      def description
+        @description ||= argument_description(@node) || kwargs.description || block.description
+      end
+
+      def kwargs
+        @kwargs ||= Argument::Kwargs.new(@node)
+      end
+
+      def block
+        @block ||= Argument::Block.new(@node.parent)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    class Argument
+      class Block
+        extend RuboCop::NodePattern::Macros
+
+        def_node_matcher :argument_block, <<~PATTERN
+          (block
+            (send nil? :argument ...)
+            (args)
+            $...
+          )
+        PATTERN
+
+        def_node_matcher :description_kwarg?, <<~PATTERN
+          (send nil? :description (str ...))
+        PATTERN
+
+        def initialize(argument_node)
+          @nodes = argument_block(argument_node) || []
+        end
+
+        def description
+          @nodes.find { |kwarg| description_kwarg?(kwarg) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    class Argument
+      class Kwargs
+        extend RuboCop::NodePattern::Macros
+
+        def_node_matcher :argument_kwargs, <<~PATTERN
+          (send nil? :argument
+            ...
+            (hash
+              $...
+            )
+          )
+        PATTERN
+
+        def_node_matcher :description_kwarg?, <<~PATTERN
+          (pair (sym :description) ...)
+        PATTERN
+
+        def initialize(argument_node)
+          @nodes = argument_kwargs(argument_node)
+        end
+
+        def description
+          @nodes.find { |kwarg| description_kwarg?(kwarg) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/graphql/ext/snake_case.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    module Ext
+      module SnakeCase
+        SNAKE_CASE = /^[\da-z_]+[!?=]?$/
+
+        refine Symbol do
+          def snake_case?
+            match?(SNAKE_CASE)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/graphql/field.rb

@@ -6,39 +6,19 @@ module RuboCop
       extend Forwardable
       extend RuboCop::NodePattern::Macros
 
-      def_delegators :@node, :sibling_index, :parent, :ancestors
-
-      def_node_matcher :field_kwargs, <<~PATTERN
-        (send nil? :field
-          ...
-          (hash
-            $...
-          )
-        )
-      PATTERN
+      def_delegators :@node, :sibling_index, :parent
 
       def_node_matcher :field_name, <<~PATTERN
-        (send nil? :field (:sym $...) ...)
+        (send nil? :field (:sym $_) ...)
       PATTERN
 
-      def_node_matcher :field_description, <<~PATTERN
-        (send nil? :field _ _ (:str $...) ...)
+      def_node_matcher :field_with_body_name, <<~PATTERN
+        (block
+        (send nil? :field (:sym $_) ...)...)
       PATTERN
 
-      def_node_matcher :resolver_kwarg?, <<~PATTERN
-        (pair (sym :resolver) ...)
-      PATTERN
-
-      def_node_matcher :method_kwarg?, <<~PATTERN
-        (pair (sym :method) ...)
-      PATTERN
-
-      def_node_matcher :hash_key_kwarg?, <<~PATTERN
-        (pair (sym :hash_key) ...)
-      PATTERN
-
-      def_node_matcher :resolver_method_option, <<~PATTERN
-        (pair (sym :resolver_method) (sym $...))
+      def_node_matcher :field_description, <<~PATTERN
+        (send nil? :field _ _ (:str $_) ...)
       PATTERN
 
       attr_reader :node
@@ -48,31 +28,52 @@ module RuboCop
       end
 
       def name
-        @name ||= field_name(@node).first
+        @name ||= field_name(@node) || field_with_body_name(@node)
+      end
+
+      def underscore_name
+        @underscore_name ||= begin
+          word = name.to_s.dup
+          word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.tr!("-", "_")
+          word.downcase!
+          word
+        end
       end
 
       def description
-        @name ||= field_description(@node)
+        @description ||= field_description(@node) || kwargs.description || block.description
+      end
+
+      def resolver_method_name
+        kwargs.resolver_method_name || name
       end
 
       def kwargs
-        @kwargs ||= field_kwargs(@node) || []
+        @kwargs ||= Field::Kwargs.new(@node)
       end
 
-      def resolver
-        kwargs.find { |kwarg| resolver_kwarg?(kwarg) }
+      def block
+        @block ||= Field::Block.new(@node.parent)
       end
 
-      def method
-        kwargs.find { |kwarg| method_kwarg?(kwarg) }
+      def schema_member
+        @schema_member ||= SchemaMember.new(root_node)
       end
 
-      def hash_key
-        kwargs.find { |kwarg| hash_key_kwarg?(kwarg) }
+      private
+
+      def root_node
+        @node.ancestors.find { |parent| root_node?(parent) }
       end
 
-      def resolver_method_name
-        @resolver_method_name ||= kwargs.flat_map { |kwarg| resolver_method_option(kwarg) }.compact.first || name
+      def root_node?(node)
+        node.parent.nil? || node.parent.module_type? || root_with_siblings?(node.parent)
+      end
+
+      def root_with_siblings?(node)
+        node.begin_type? && node.parent.nil?
       end
     end
   end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    class Field
+      class Block
+        extend RuboCop::NodePattern::Macros
+
+        def_node_matcher :field_block, <<~PATTERN
+          (block
+            (send nil? :field ...)
+            (args)
+            $...
+          )
+        PATTERN
+
+        def_node_matcher :description_kwarg?, <<~PATTERN
+          (send nil? :description (str ...))
+        PATTERN
+
+        def initialize(field_node)
+          @nodes = field_block(field_node) || []
+        end
+
+        def description
+          @nodes.find { |kwarg| description_kwarg?(kwarg) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    class Field
+      class Kwargs
+        extend RuboCop::NodePattern::Macros
+
+        def_node_matcher :field_kwargs, <<~PATTERN
+          (send nil? :field
+            ...
+            (hash
+              $...
+            )
+          )
+        PATTERN
+
+        def_node_matcher :resolver_kwarg?, <<~PATTERN
+          (pair (sym :resolver) ...)
+        PATTERN
+
+        def_node_matcher :method_kwarg?, <<~PATTERN
+          (pair (sym :method) ...)
+        PATTERN
+
+        def_node_matcher :hash_key_kwarg?, <<~PATTERN
+          (pair (sym :hash_key) ...)
+        PATTERN
+
+        def_node_matcher :description_kwarg?, <<~PATTERN
+          (pair (sym :description) ...)
+        PATTERN
+
+        def_node_matcher :resolver_method_option, <<~PATTERN
+          (pair (sym :resolver_method) (sym $...))
+        PATTERN
+
+        def initialize(field_node)
+          @nodes = field_kwargs(field_node) || []
+        end
+
+        def resolver
+          @nodes.find { |kwarg| resolver_kwarg?(kwarg) }
+        end
+
+        def method
+          @nodes.find { |kwarg| method_kwarg?(kwarg) }
+        end
+
+        def hash_key
+          @nodes.find { |kwarg| hash_key_kwarg?(kwarg) }
+        end
+
+        def description
+          @nodes.find { |kwarg| description_kwarg?(kwarg) }
+        end
+
+        def resolver_method_name
+          @resolver_method_name ||= @nodes.flat_map { |kwarg| resolver_method_option(kwarg) }.compact.first
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/graphql/node_pattern.rb

@@ -6,15 +6,23 @@ module RuboCop
       extend RuboCop::NodePattern::Macros
 
       def_node_matcher :field_definition?, <<~PATTERN
-        (send nil? :field ...)
+        (send nil? :field (:sym _) ...)
       PATTERN
 
       def_node_matcher :field_definition_with_body?, <<~PATTERN
         (block
-          (send nil? :field ...)
+          (send nil? :field (:sym _) ...)
           ...
         )
       PATTERN
+
+      def_node_matcher :argument?, <<~PATTERN
+        (send nil? :argument (:sym _) ...)
+      PATTERN
+
+      def field?(node)
+        field_definition?(node) || field_definition_with_body?(node)
+      end
     end
   end
 end

data/lib/rubocop/graphql/schema_member.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module GraphQL
+    class SchemaMember
+      extend RuboCop::NodePattern::Macros
+
+      def_node_matcher :class_contents, <<~PATTERN
+        (class _ _ $_)
+      PATTERN
+
+      attr_reader :node
+
+      def initialize(node)
+        @node = node
+      end
+
+      def find_method_definition(method_name)
+        body.find { |node| node.def_type? && node.method_name == method_name }
+      end
+
+      def body
+        contents = class_contents(@node)
+
+        if contents.nil?
+          []
+        elsif contents.begin_type?
+          contents.child_nodes
+        else
+          [contents]
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/graphql/version.rb

@@ -1,5 +1,5 @@
 module RuboCop
   module GraphQL
-    VERSION = "0.1.2"
+    VERSION = "0.4.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-graphql
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.4.0
 platform: ruby
 authors:
 - Dmitry Tsepelev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-25 00:00:00.000000000 Z
+date: 2020-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -77,15 +77,30 @@ files:
 - README.md
 - config/default.yml
 - lib/rubocop-graphql.rb
+- lib/rubocop/cop/graphql/argument_description.rb
+- lib/rubocop/cop/graphql/argument_name.rb
 - lib/rubocop/cop/graphql/cop.rb
+- lib/rubocop/cop/graphql/extract_input_type.rb
+- lib/rubocop/cop/graphql/extract_type.rb
 - lib/rubocop/cop/graphql/field_definitions.rb
 - lib/rubocop/cop/graphql/field_description.rb
+- lib/rubocop/cop/graphql/field_hash_key.rb
+- lib/rubocop/cop/graphql/field_method.rb
+- lib/rubocop/cop/graphql/field_name.rb
+- lib/rubocop/cop/graphql/object_description.rb
 - lib/rubocop/cop/graphql/resolver_method_length.rb
 - lib/rubocop/cop/graphql_cops.rb
 - lib/rubocop/graphql.rb
+- lib/rubocop/graphql/argument.rb
+- lib/rubocop/graphql/argument/block.rb
+- lib/rubocop/graphql/argument/kwargs.rb
+- lib/rubocop/graphql/ext/snake_case.rb
 - lib/rubocop/graphql/field.rb
+- lib/rubocop/graphql/field/block.rb
+- lib/rubocop/graphql/field/kwargs.rb
 - lib/rubocop/graphql/inject.rb
 - lib/rubocop/graphql/node_pattern.rb
+- lib/rubocop/graphql/schema_member.rb
 - lib/rubocop/graphql/version.rb
 homepage: https://github.com/DmitryTsepelev/rubocop-graphql
 licenses: