rubocop-graphql 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 328663a392bcbb8e7a53bfaf2ba8e7323e9382893c8f290fa6b40e965155ebe1
+  data.tar.gz: cb76dad975e6dab191f1fac2ae6c45b677fb06bddbb26f36494a18108e1acf56
+SHA512:
+  metadata.gz: a87c4e9ee55fb176eaf98ba520a7942c7a4ee4af3531b7cc90a0039f739a5e5400ce4e21b0d694e59b00ca0bb2771585f07a50699c55496a8794eec1a38900f3
+  data.tar.gz: cedeb68f255f806a1e12de6776722f3aadce5f82fe7c0e4ace7979593d7f84abc8f27fee1cff5ced953076f88247e4aadf0599f30b02b5a35436d946f976a353

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 DmitryTsepelev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,78 @@
+# RuboCop::GraphQL
+
+[Rubocop](https://github.com/rubocop-hq/rubocop) extension for enforcing [graphql-ruby](https://github.com/rmosolgo/graphql-ruby) best practices.
+
+<p align="center">
+  <a href="https://evilmartians.com/?utm_source=graphql-rubocop">
+    <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
+  </a>
+</p>
+
+## Installation
+
+Install the gem:
+
+```bash
+gem install rubocop-graphql
+```
+
+If you use bundler put this in your Gemfile:
+
+```ruby
+gem 'rubocop-graphql', require: false
+```
+
+## Usage
+
+You need to tell RuboCop to load the GraphQL extension. There are three ways to do this:
+
+### RuboCop configuration file
+
+Put this into your `.rubocop.yml`.
+
+```yaml
+require: rubocop-graphql
+```
+
+Alternatively, use the following array notation when specifying multiple extensions.
+
+```yaml
+require:
+  - rubocop-other-extension
+  - rubocop-graphql
+```
+
+Now you can run `rubocop` and it will automatically load the RuboCop GraphQL cops together with the standard cops.
+
+### Command line
+
+```sh
+rubocop --require rubocop-graphql
+```
+
+### Rake task
+
+```ruby
+RuboCop::RakeTask.new do |task|
+  task.requires << 'rubocop-graphql'
+end
+```
+
+## The Cops
+
+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 GraphQL cops just like any other cop. For example:
+
+```yaml
+GraphQL/ResolverMethodLength:
+  Max: 3
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/DmitryTsepelev/rubocop-graphql.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/config/default.yml

@@ -0,0 +1,72 @@
+AllCops:
+  GraphQL:
+    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: 'Checks resolver methods are not too long'
+  Max: 10
+  CountComments: false
+  ExcludedMethods: []
+
+GraphQL/FieldDefinitions:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'Checks consistency of field definitions'
+  EnforcedStyle: group_definitions
+  SupportedStyles:
+    - group_definitions
+    - define_resolver_after_definition
+
+GraphQL/FieldDescription:
+  Enabled: true
+  VersionAdded: '0.80'
+  Description: 'Ensures all fields have a description'
+
+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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+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!
+
+require_relative "rubocop/cop/graphql_cops"

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

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module RuboCop
+  # Inspied by https://github.com/rubocop-hq/rubocop-rspec/blob/3a2088f79737e2e8e0e21482783f7d61411bf021/lib/rubocop/cop/rspec/cop.rb
+  module Cop
+    WorkaroundGraphqlCop = Cop.dup
+
+    # Clone of the the normal RuboCop::Cop::Cop class so we can rewrite
+    # the inherited method without breaking functionality
+    class WorkaroundGraphqlCop
+      # Remove the Cop.inherited method to be a noop. Our RSpec::Cop
+      # class will invoke the inherited hook instead
+      class << self
+        undef inherited
+        def inherited(*)
+        end
+      end
+
+      # Special case `Module#<` so that the rspec support rubocop exports
+      # is compatible with our subclass
+      def self.<(other)
+        other.equal?(RuboCop::Cop::Cop) || super
+      end
+    end
+    private_constant(:WorkaroundGraphqlCop)
+
+    module GraphQL
+      # @abstract parent class to graphql-ruby cops
+      #
+      # The criteria for whether rubocop-rspec analyzes a certain ruby file
+      # is configured via `AllCops/GraphQL`. For example, if you want to
+      # customize your project to scan all files within a `graph/` directory
+      # then you could add this to your configuration:
+      #
+      # @example configuring analyzed paths
+      #
+      #   AllCops:
+      #     GraphQL:
+      #       Patterns:
+      #       - '(?:^|/)graph/'
+      class Cop < WorkaroundGraphqlCop
+        DEFAULT_CONFIGURATION =
+          RuboCop::GraphQL::CONFIG.fetch("AllCops").fetch("GraphQL")
+
+        DEFAULT_PATTERN_RE = Regexp.union(
+          DEFAULT_CONFIGURATION.fetch("Patterns")
+                               .map(&Regexp.public_method(:new))
+        )
+
+        # Invoke the original inherited hook so our cops are recognized
+        def self.inherited(subclass)
+          RuboCop::Cop::Cop.inherited(subclass)
+        end
+
+        def relevant_file?(file)
+          relevant_rubocop_graphql_file?(file) && super
+        end
+
+        private
+
+        def relevant_rubocop_graphql_file?(file)
+          graphql_pattern =~ file
+        end
+
+        def graphql_pattern
+          if rspec_graphql_config?
+            Regexp.union(rspec_graphql_config.map(&Regexp.public_method(:new)))
+          else
+            DEFAULT_PATTERN_RE
+          end
+        end
+
+        def all_cops_config
+          config
+            .for_all_cops
+        end
+
+        def rspec_graphql_config?
+          return unless all_cops_config.key?("GraphQL")
+
+          all_cops_config.fetch("GraphQL").key?("Patterns")
+        end
+
+        def rspec_graphql_config
+          all_cops_config
+            .fetch("GraphQL", DEFAULT_CONFIGURATION)
+            .fetch("Patterns")
+        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