rubocop-gusto 10.0.0

data/config/rails.yml

@@ -0,0 +1,122 @@
+#
+# This file should be inherited alongside default.yml for Rails projects
+#
+# After you add a rule, sort this file with `bundle exec rubocop-gusto sort config/rails.yml`
+
+plugins:
+  - rubocop-rails
+
+AllCops:
+  TargetRubyVersion: <%= RbConfig::CONFIG['RUBY_API_VERSION'] %>
+  MaxFilesInCache: 100000
+  Exclude:
+    - './.[!.]*' # ignore all dotfiles
+    - './.[!.]*/**/*' # ignore all dot directories
+    - 'config/boot.rb'
+    - 'db/**/*schema.rb'
+    - 'db/seeds{.rb,/**/*}'
+
+Rails:
+  Enabled: true
+
+Rails/ActiveRecordAliases:
+  Enabled: false
+
+Rails/ActiveRecordOverride:
+  Enabled: true
+
+Rails/ApplicationRecord:
+  AutoCorrect: true
+
+Rails/BulkChangeTable:
+  Enabled: false
+
+Rails/Date:
+  AutoCorrect: false
+  Enabled: true
+
+Rails/Delegate:
+  # Incompatible with Sorbet
+  Enabled: false
+  EnforceForPrefixed: false
+
+Rails/DynamicFindBy:
+  AllowedMethods:
+    - find_by_sql
+    - find_by_uuid_or_id
+    - find_by_uuid_or_id!
+
+Rails/EagerEvaluationLogMessage:
+  Enabled: true
+  AutoCorrect: true
+
+Rails/EnumHash:
+  Include:
+    - '**/app/models/**/*'
+
+Rails/Exit:
+  Include:
+    - app/**/*
+    - config/**/*
+    - lib/**/*
+    - packs/**/{app,lib}/**/*
+
+Rails/FindEach:
+  Include:
+    - '**/app/models/**/*'
+
+Rails/HasAndBelongsToMany:
+  Include:
+    - '**/app/models/**/*'
+
+Rails/HasManyOrHasOneDependent:
+  Enabled: false
+
+Rails/HelperInstanceVariable:
+  Include:
+    - '**/app/helpers/**/*'
+
+Rails/HttpPositionalArguments:
+  AutoCorrect: true
+  Include:
+    - packs/**/spec/{controllers,fixture_generators}/**/*
+    - spec/{controllers,fixture_generators}/**/*
+
+Rails/InverseOf:
+  Include:
+    - '**/app/models/**/*'
+
+Rails/LexicallyScopedActionFilter:
+  Include:
+    - '**/app/controllers/**/*'
+    - '**/app/mailers/**/*'
+
+Rails/NotNullColumn:
+  Enabled: false
+
+Rails/ReadWriteAttribute:
+  Enabled: false
+
+Rails/SaveBang:
+  SafeAutoCorrect: false
+
+Rails/SkipsModelValidations:
+  Enabled: true
+
+Rails/TimeZone:
+  Enabled: true
+
+Rails/UniqueValidationWithoutIndex:
+  Enabled: true
+
+Rails/UnknownEnv:
+  Environments:
+    - demo
+    - development
+    - production
+    - staging
+    - test
+
+Rails/Validation:
+  Include:
+    - '**/models/**/*'

data/exe/gusto-rubocop

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# typed: strict
+
+# This file is here to conform to our gusto-* convention.
+# rubocop gems have their own naming convention so we're doing both.
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'rubocop/gusto/cli'
+
+RuboCop::Gusto::Cli.start(ARGV)

data/exe/rubocop-gusto

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+# typed: strict
+
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+
+require 'rubocop/gusto/cli'
+
+RuboCop::Gusto::Cli.start(ARGV)

data/lib/rubocop/cop/gusto/bootsnap_load_file.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Do not use Bootsnap to load files. Use `require` instead.
+      class BootsnapLoadFile < Base
+        PROHIBITED_CONSTANTS = Set[:YAML, :JSON].freeze
+        RESTRICT_ON_SEND = %i(load).freeze
+
+        # @!method yaml_or_json_load(node)
+        def_node_matcher :yaml_or_json_load, '(send $(const nil? PROHIBITED_CONSTANTS) :load ...)'
+
+        # @!method file_read(node)
+        def_node_matcher :file_read, '(send (const nil? :File) :read $_)'
+
+        # @!method load_inside_file_open(node)
+        def_node_matcher :load_inside_file_open, <<~PATTERN
+          (block
+            (send
+              (const nil? :File) :open
+              $(str _))
+            (args
+              (arg _file))
+            (send
+              $(const nil? :YAML) :load
+              (lvar _file))
+          )
+        PATTERN
+
+        def on_block(node)
+          load_inside_file_open(node) do |file_path_node, constant_node|
+            add_offense(node, message: "Use #{constant_node.source}.load_file(#{file_path_node.source}) to improve load time with bootsnap")
+          end
+        end
+        alias_method :on_numblock, :on_block
+
+        def on_send(node)
+          yaml_or_json_load(node) do |constant_node|
+            on_load(node, constant_node)
+          end
+        end
+
+        private
+
+        # Look for File.read as the first argument
+        def on_load(node, constant_node)
+          return unless node.first_argument
+
+          file_read(node.first_argument) do |read_file_node|
+            add_offense(node, message: "Use #{constant_node.source}.load_file(#{read_file_node.source}) to improve load time with bootsnap")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/datadog_constant.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      class DatadogConstant < Base
+        MSG = 'Do not call Datadog directly, use an appropriate wrapper library.'
+        NAMESPACE = 'Datadog'
+
+        def on_const(node)
+          add_offense(node) if node.const_name == NAMESPACE
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/execute_migration.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      class ExecuteMigration < Base
+        MSG = 'Do not use `execute` to run raw SQL in a migration. Run the query from a backfill rake task or pass the SQL options to the `add_column`/`change_column` method.'
+        RESTRICT_ON_SEND = [:execute].freeze
+
+        def on_send(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/factory_classes_or_modules.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      class FactoryClassesOrModules < Base
+        MSG = 'Do not define modules or classes in factory directories - they break reloading'
+
+        def on_class(node)
+          add_offense(node)
+        end
+
+        def on_module(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/min_by_max_by.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Checks for the use of `min` or `max` with a proc. Corrects to `min_by` or `max_by`.
+      #
+      # @safety This cop is unsafe because it will change the behavior of the code.
+      #
+      # @example
+      #  # bad
+      #  arr = [[3, 3, 3], [2, 2], [1]]
+      #  arr.min(&:count)
+      #   => [3, 3, 3] - oh no how did this happen?
+      #  arr = [[2,2],[1,1],[3,3,3]]
+      #  arr.min &:first # => TypeError: no implicit conversion of Array into Integer
+      #  arr = [[1, 1], [3, 3], [2, 2]]
+      #  arr.max { |pair| pair.first } # => [2, 2] (semantically incorrect)
+      #
+      #  # good
+      #  arr = [[2,2],[1],[3,3,3]]
+      #  arr.min_by &:first # => [1]
+      #  arr = [[1, 1], [3, 3], [2, 2]]
+      #  arr.max_by { |pair| pair.first } # => [3, 3]
+      #
+      class MinByMaxBy < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%{method}_by` instead of `%{method}` with a proc like `&:my_method_proc`. `%{method}` expects Comparable elements.'
+        RESTRICT_ON_SEND = %i(min max).freeze
+
+        def on_send(node)
+          return unless node.arguments?
+          return unless node.first_argument.block_pass_type?
+
+          method_name = node.method_name
+          add_offense(node, message: format(MSG, method: method_name)) do |corrector|
+            corrector.replace(node, node.source.sub(method_name.to_s, "#{method_name}_by"))
+          end
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/no_metaprogramming.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Checks and discourages the use of metaprogramming techniques that make code harder to
+      # understand, debug, and maintain.
+      #
+      # @example
+      #
+      #   # bad - using define_method
+      #   define_method(:my_method) do |arg|
+      #     puts arg
+      #   end
+      #
+      #   # good - using regular method definition
+      #   def my_method(arg)
+      #     puts arg
+      #   end
+      #
+      #   # bad - using instance_eval
+      #   object.instance_eval do
+      #     def foo
+      #       bar
+      #     end
+      #   end
+      #
+      #   # good - defining methods on the class
+      #   class MyClass
+      #     def foo
+      #       bar
+      #     end
+      #   end
+      #
+      #   # bad - using method_missing
+      #   def method_missing(method, *args)
+      #     if method.to_s.start_with?('find_by_')
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # bad - using define_singleton_method
+      #   object.define_singleton_method(:foo) { bar }
+      #
+      #   # good - define class methods directly
+      #   def self.foo
+      #     bar
+      #   end
+      #
+      #   # bad - using class_eval
+      #   MyClass.class_eval do
+      #     def foo
+      #       bar
+      #     end
+      #   end
+      #
+      class NoMetaprogramming < Base
+        RESTRICT_ON_SEND = %i(define_method instance_eval define_singleton_method class_eval).freeze
+
+        # @!method included_definition?(node)
+        def_node_matcher :included_definition?, <<~PATTERN
+          (defs self :included ...)
+        PATTERN
+
+        # @!method inherited_definition?(node)
+        def_node_matcher :inherited_definition?, <<~PATTERN
+          (defs self :inherited ...)
+        PATTERN
+
+        # @!method using_method_missing?(node)
+        def_node_matcher :using_method_missing?, <<~PATTERN
+          (def :method_missing ...)
+        PATTERN
+
+        # @!method using_define_method?(node)
+        def_node_matcher :using_define_method?, <<~PATTERN
+          (send _ :define_method ...)
+        PATTERN
+
+        # @!method using_instance_eval?(node)
+        def_node_matcher :using_instance_eval?, <<~PATTERN
+          (send _ :instance_eval ...)
+        PATTERN
+
+        # @!method using_class_eval?(node)
+        def_node_matcher :using_class_eval?, <<~PATTERN
+          (send _ :class_eval ...)
+        PATTERN
+
+        # @!method using_define_singleton_method_on_klass_instance?(node)
+        def_node_matcher :using_define_singleton_method_on_klass_instance?, <<~PATTERN
+          (send _ :define_singleton_method ...)
+        PATTERN
+
+        def on_defs(node)
+          included_definition?(node) do
+            add_offense(node, message: 'self.included modifies the behavior of classes at runtime. Please avoid using if possible.')
+          end
+
+          inherited_definition?(node) do
+            add_offense(node, message: 'self.inherited modifies the behavior of classes at runtime. Please avoid using if possible.')
+          end
+        end
+
+        def on_def(node)
+          using_method_missing?(node) do
+            add_offense(node, message: 'Please do not use method_missing. Instead, explicitly define the methods you expect to receive.')
+          end
+        end
+
+        def on_send(node)
+          using_define_method?(node) do
+            add_offense(node, message: 'Please do not define methods dynamically, instead define them using `def` and explicitly. This helps readability for both humans and machines.')
+          end
+
+          using_define_singleton_method_on_klass_instance?(node) do
+            add_offense(node, message: 'Please do not use define_singleton_method. Instead, define the method explicitly using `def self.my_method; end`')
+          end
+
+          using_instance_eval?(node) do
+            add_offense(node, message: 'Please do not use instance_eval to augment behavior onto an instance. Instead, define the method you want to use in the class definition.')
+          end
+
+          using_class_eval?(node) do
+            add_offense(node, message: 'Please do not use class_eval to augment behavior onto a class. Instead, define the method you want to use in the class definition.')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/no_rescue_error_message_checking.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Checks for the presence of error message checking within rescue blocks.
+      #
+      # This is brittle and can break easily.
+      #
+      # NOTE: We submitted this upstream here: https://github.com/rubocop/rubocop/pull/13352
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #   rescue => e
+      #     if e.message.match?(/Duplicate entry/)
+      #       handle_error
+      #     end
+      #   end
+      #
+      #  # bad
+      #  begin
+      #    something
+      #  rescue => e
+      #    unless e.message.match?(/Duplicate entry/)
+      #      handle_error
+      #    end
+      #  end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue ActiveRecord::RecordNotUnique => e
+      #     handle_error
+      #   end
+      #
+      class NoRescueErrorMessageChecking < Base
+        MSG = 'Avoid checking error message while handling exceptions. This is brittle and can break easily.'
+        METHODS_TO_CHECK = %i(match? include? ==).to_set.freeze
+
+        def on_rescue(node)
+          node.resbody_branches.last.each_descendant(:if, :unless).each do |condition_node|
+            add_offense(condition_node) if message_check?(condition_node)
+          end
+        end
+
+        private
+
+        def message_check?(condition_node)
+          return unless condition_node.condition.send_type?
+          return unless condition_node.condition.receiver
+          return unless METHODS_TO_CHECK.include?(condition_node.condition.method_name)
+
+          if condition_node.condition.method?(:==)
+            (condition_node.condition.receiver.str_type? && condition_node.condition.first_argument.method?(:message)) ||
+              (condition_node.condition.receiver.send_type? && condition_node.condition.receiver.method?(:message))
+          else
+            condition_node.condition.receiver.type?(:send, :regexp, :array)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/no_send.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Do not call a private method via __send__
+      #
+      # @example
+      #   # bad
+      #   foo.__send__(:bar)
+      #   __send__(:run_baz)
+      #
+      #   # good
+      #   There's no better alternative, don't call private methods.
+      #
+      class NoSend < Base
+        MSG = 'Do not call a private method via `__send__`.'
+        RESTRICT_ON_SEND = %i(__send__).freeze
+
+        # @!method invoke_private_method_send?(node)
+        def_node_matcher :invoke_private_method_send?, <<~PATTERN
+          (call _ :__send__ (sym _))
+        PATTERN
+
+        def on_send(node)
+          invoke_private_method_send?(node) { add_offense(node) }
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/object_in.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Identifies uses of `Object#in?`, which iterates over each
+      # item in a `Range` to see if a specified item is there. In contrast,
+      # `Range#cover?` simply compares the target item with the beginning and
+      # end points of the `Range`. In a great majority of cases, this is what
+      # is wanted.
+      #
+      # @safety
+      # This cop is unsafe. Here is an example of a case where `Range#cover?`
+      # may not provide the desired result:
+      #
+      #  ('a'..'z').cover?('yellow') # => true
+      #
+      class ObjectIn < Base
+        MSG = 'Use `Range#cover?` instead of `Object#in?`.'
+        RESTRICT_ON_SEND = [:in?].freeze
+
+        # @!method object_in(node)
+        def_node_matcher :object_in, <<-PATTERN
+          (call _ :in? {range (begin range)})
+        PATTERN
+
+        def on_send(node)
+          return unless object_in(node)
+
+          add_offense(node)
+        end
+        alias_method :on_csend, :on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/paperclip_or_attachable.rb

@@ -0,0 +1,17 @@
+# typed: ignore
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      class PaperclipOrAttachable < Base
+        MSG = 'No more new paperclip or Attachable are allowed. New attachments should use ActiveStorage instead'
+        RESTRICT_ON_SEND = %i(has_attached_file has_pdf_attachment has_attachment).freeze
+
+        def on_send(node)
+          add_offense(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/gusto/perform_class_method.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Gusto
+      # Checks for a defined `.perform` class method in Sidekiq workers. These
+      # are most likely intended to have been instance methods.
+      #
+      # @example
+      #   # bad
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #
+      #     def self.perform
+      #       # ...
+      #     end
+      #   end
+      #
+      #   # good
+      #   class MyWorker
+      #     include Sidekiq::Worker
+      #
+      #     def perform
+      #       # ...
+      #     end
+      #   end
+      #
+      class PerformClassMethod < Base
+        MSG = 'Class-level `perform` method is being defined. Did you mean to use an instance method?'
+        WORKER_FALLBACK = %w(Sidekiq::Worker).freeze
+        WORKER_MODULES = 'WorkerModules'
+
+        def on_def(node)
+          return unless node.method?(:perform)
+          return unless (method_type = perform_class_method_type(node))
+          return unless is_sidekiq_worker?(node, method_type)
+
+          add_offense(node)
+        end
+        alias_method :on_defs, :on_def
+
+        private
+
+        def perform_class_method_type(node)
+          if node.receiver&.self_type?
+            :self
+          elsif node.parent.sclass_type?
+            :sclass
+          end
+        end
+
+        def is_sidekiq_worker?(search_node, method_type)
+          search_node = search_node.parent if method_type == :sclass
+          search_node.parent.children.any? do |sibling|
+            next if sibling.nil?
+            next unless is_include?(sibling)
+            next unless sibling.first_argument.const_type?
+
+            worker_modules.include?(sibling.first_argument.const_name)
+          end
+        end
+
+        def is_include?(node)
+          node.send_type? && node.method?(:include)
+        end
+
+        def worker_modules
+          @worker_modules ||= cop_config.fetch(WORKER_MODULES, WORKER_FALLBACK)
+        end
+      end
+    end
+  end
+end