rubocop-graphql 0.3.0

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

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      # This cop checks consistency of field definitions
+      #
+      # EnforcedStyle supports two modes:
+      #
+      # `group_definitions` : all field definitions should be grouped together.
+      #
+      # `define_resolver_after_definition` : if resolver method exists it should
+      # be defined right after the field definition.
+      #
+      # @example EnforcedStyle: group_definitions (default)
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     field :first_name, String, null: true
+      #     field :last_name, String, null: true
+      #
+      #     def first_name
+      #       object.contact_data.first_name
+      #     end
+      #
+      #     def last_name
+      #       object.contact_data.last_name
+      #     end
+      #   end
+      #
+      # @example EnforcedStyle: define_resolver_after_definition
+      #   # good
+      #
+      #   class UserType < BaseType
+      #     field :first_name, String, null: true
+      #
+      #     def first_name
+      #       object.contact_data.first_name
+      #     end
+      #
+      #     field :last_name, String, null: true
+      #
+      #     def last_name
+      #       object.contact_data.last_name
+      #     end
+      #   end
+      class FieldDefinitions < Cop
+        include ConfigurableEnforcedStyle
+        include RuboCop::GraphQL::NodePattern
+        include RuboCop::Cop::RangeHelp
+
+        def_node_matcher :field_kwargs, <<~PATTERN
+          (send nil? :field
+            ...
+            (hash
+              $...
+            )
+          )
+        PATTERN
+
+        def on_send(node)
+          return if !field_definition?(node) || style != :define_resolver_after_definition
+
+          field = RuboCop::GraphQL::Field.new(node)
+          check_resolver_is_defined_after_definition(field)
+        end
+
+        def on_class(node)
+          return if style != :group_definitions
+
+          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
+
+        GROUP_DEFS_MSG = "Group all field definitions together."
+
+        def check_grouped_field_declarations(body)
+          fields = body.select { |node| field?(node) }
+
+          first_field = fields.first
+
+          fields.each_with_index do |node, idx|
+            next if node.sibling_index == first_field.sibling_index + idx
+
+            add_offense(node, message: GROUP_DEFS_MSG)
+          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.kwargs.resolver || field.kwargs.method || field.kwargs.hash_key
+
+          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)
+            field.parent.sibling_index
+          else
+            field.sibling_index
+          end
+
+          return if method_definition.sibling_index - field_sibling_index == 1
+
+          add_offense(field.node, message: RESOLVER_AFTER_FIELD_MSG)
+        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)
+
+          range_to_remove = range_with_surrounding_space(range: field_definition.loc.expression, side: :left)
+          corrector.remove(range_to_remove)
+        end
+
+        def indent(node)
+          " " * node.location.column
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/graphql/field_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 UserType < BaseType
+      #     field :name, String, "Name of the user", null: true
+      #   end
+      #
+      #   # bad
+      #
+      #   class UserType < BaseType
+      #     field :name, String, null: true
+      #   end
+      #
+      class FieldDescription < Cop
+        include RuboCop::GraphQL::NodePattern
+
+        MSG = "Missing field description"
+
+        def on_send(node)
+          return unless field_definition?(node)
+
+          field = RuboCop::GraphQL::Field.new(node)
+
+          add_offense(node) unless field.description
+        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/resolver_method_length.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module GraphQL
+      # This cop checks if the length of a resolver method exceeds some maximum value.
+      # Comment lines can optionally be ignored.
+      #
+      # The maximum allowed length is configurable using the Max option.
+      class ResolverMethodLength < Cop
+        include RuboCop::Cop::ConfigurableMax
+        include RuboCop::Cop::TooManyLines
+
+        LABEL = "ResolverMethod"
+
+        def_node_matcher :field_definition, <<~PATTERN
+          (send nil? :field (sym $...) ...)
+        PATTERN
+
+        def on_def(node)
+          excluded_methods = cop_config["ExcludedMethods"]
+          return if excluded_methods.include?(String(node.method_name))
+
+          check_code_length(node) if field_is_defined?(node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def field_is_defined?(node)
+          node.parent.children.flat_map { |child| field_definition(child) }.include?(node.method_name)
+        end
+
+        def cop_label
+          LABEL
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/graphql_cops.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+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_method"
+require_relative "graphql/field_name"
+require_relative "graphql/resolver_method_length"
+require_relative "graphql/object_description"

data/lib/rubocop/graphql.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # RuboCop GraphQL project namespace
+  module GraphQL
+    PROJECT_ROOT = Pathname.new(__dir__).parent.parent.expand_path.freeze
+    CONFIG_DEFAULT = PROJECT_ROOT.join("config", "default.yml").freeze
+    CONFIG = YAML.safe_load(CONFIG_DEFAULT.read).freeze
+
+    private_constant(:CONFIG_DEFAULT, :PROJECT_ROOT)
+  end
+end