rubocop-rails 2.11.2 → 2.19.1

data/lib/rubocop/cop/rails/active_support_on_load.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for Rails framework classes that are patched directly instead of using Active Support load hooks. Direct
+      # patching forcibly loads the framework referenced, using hooks defers loading until it's actually needed.
+      #
+      # @safety
+      #   While using lazy load hooks is recommended, it changes the order in which is code is loaded and may reveal
+      #   load order dependency bugs.
+      #
+      # @example
+      #
+      #   # bad
+      #   ActiveRecord::Base.include(MyClass)
+      #
+      #   # good
+      #   ActiveSupport.on_load(:active_record) { include MyClass }
+      class ActiveSupportOnLoad < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[prepend include extend].freeze
+        LOAD_HOOKS = {
+          'ActionCable' => 'action_cable',
+          'ActionCable::Channel::Base' => 'action_cable_channel',
+          'ActionCable::Connection::Base' => 'action_cable_connection',
+          'ActionCable::Connection::TestCase' => 'action_cable_connection_test_case',
+          'ActionController::API' => 'action_controller',
+          'ActionController::Base' => 'action_controller',
+          'ActionController::TestCase' => 'action_controller_test_case',
+          'ActionDispatch::IntegrationTest' => 'action_dispatch_integration_test',
+          'ActionDispatch::Request' => 'action_dispatch_request',
+          'ActionDispatch::Response' => 'action_dispatch_response',
+          'ActionDispatch::SystemTestCase' => 'action_dispatch_system_test_case',
+          'ActionMailbox::Base' => 'action_mailbox',
+          'ActionMailbox::InboundEmail' => 'action_mailbox_inbound_email',
+          'ActionMailbox::Record' => 'action_mailbox_record',
+          'ActionMailbox::TestCase' => 'action_mailbox_test_case',
+          'ActionMailer::Base' => 'action_mailer',
+          'ActionMailer::TestCase' => 'action_mailer_test_case',
+          'ActionText::Content' => 'action_text_content',
+          'ActionText::Record' => 'action_text_record',
+          'ActionText::RichText' => 'action_text_rich_text',
+          'ActionView::Base' => 'action_view',
+          'ActionView::TestCase' => 'action_view_test_case',
+          'ActiveJob::Base' => 'active_job',
+          'ActiveJob::TestCase' => 'active_job_test_case',
+          'ActiveRecord::Base' => 'active_record',
+          'ActiveStorage::Attachment' => 'active_storage_attachment',
+          'ActiveStorage::Blob' => 'active_storage_blob',
+          'ActiveStorage::Record' => 'active_storage_record',
+          'ActiveStorage::VariantRecord' => 'active_storage_variant_record',
+          'ActiveSupport::TestCase' => 'active_support_test_case'
+        }.freeze
+
+        def on_send(node)
+          receiver, method, arguments = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          return unless receiver && (hook = LOAD_HOOKS[receiver.const_name])
+
+          preferred = "ActiveSupport.on_load(:#{hook}) { #{method} #{arguments.source} }"
+          add_offense(node, message: format(MSG, prefer: preferred, current: node.source)) do |corrector|
+            corrector.replace(node, preferred)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/add_column_index.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for migrations using `add_column` that have an `index`
+      # Checks for migrations using `add_column` that have an `index`
       # key. `add_column` does not accept `index`, but also does not raise an
       # error for extra keys, so it is possible to mistakenly add the key without
       # realizing it will not actually add an index.
@@ -42,7 +42,7 @@ module RuboCop
             add_index_opts = ''
 
             if value.hash_type?
-              hash = value.loc.expression.adjust(begin_pos: 1, end_pos: -1).source.strip
+              hash = value.source_range.adjust(begin_pos: 1, end_pos: -1).source.strip
               add_index_opts = ", #{hash}"
             end
 
@@ -53,10 +53,7 @@ module RuboCop
         private
 
         def index_range(pair_node)
-          range_with_surrounding_comma(
-            range_with_surrounding_space(range: pair_node.loc.expression, side: :left),
-            :left
-          )
+          range_with_surrounding_comma(range_with_surrounding_space(pair_node.source_range, side: :left), :left)
         end
       end
     end

data/lib/rubocop/cop/rails/after_commit_override.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces that there is only one call to `after_commit`
+      # Enforces that there is only one call to `after_commit`
       # (and its aliases - `after_create_commit`, `after_update_commit`,
       # and `after_destroy_commit`) with the same callback name per model.
       #
@@ -32,6 +32,8 @@ module RuboCop
       #   after_update_commit :log_update_action
       #
       class AfterCommitOverride < Base
+        include ClassSendNodeHelper
+
         MSG = 'There can only be one `after_*_commit :%<name>s` hook defined for a model.'
 
         AFTER_COMMIT_CALLBACKS = %i[
@@ -63,18 +65,6 @@ module RuboCop
           end
         end
 
-        def class_send_nodes(class_node)
-          class_def = class_node.body
-
-          return [] unless class_def
-
-          if class_def.send_type?
-            [class_def]
-          else
-            class_def.each_child_node(:send).to_a
-          end
-        end
-
         def after_commit_callback?(node)
           AFTER_COMMIT_CALLBACKS.include?(node.method_name)
         end

data/lib/rubocop/cop/rails/application_controller.rb

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that controllers subclass ApplicationController.
+      # Checks that controllers subclass `ApplicationController`.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationController`
+      #   sneak into a controller that is not purposed to inherit logic common among other controllers.
       #
       # @example
       #
@@ -21,7 +25,7 @@ module RuboCop
 
         MSG = 'Controllers should subclass `ApplicationController`.'
         SUPERCLASS = 'ApplicationController'
-        BASE_PATTERN = '(const (const nil? :ActionController) :Base)'
+        BASE_PATTERN = '(const (const {nil? cbase} :ActionController) :Base)'
 
         # rubocop:disable Layout/ClassStructure
         include RuboCop::Cop::EnforceSuperclass

data/lib/rubocop/cop/rails/application_job.rb

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that jobs subclass ApplicationJob with Rails 5.0.
+      # Checks that jobs subclass `ApplicationJob` with Rails 5.0.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationJob`
+      #   sneak into a job that is not purposed to inherit logic common among other jobs.
       #
       # @example
       #
@@ -24,7 +28,7 @@ module RuboCop
 
         MSG = 'Jobs should subclass `ApplicationJob`.'
         SUPERCLASS = 'ApplicationJob'
-        BASE_PATTERN = '(const (const nil? :ActiveJob) :Base)'
+        BASE_PATTERN = '(const (const {nil? cbase} :ActiveJob) :Base)'
 
         # rubocop:disable Layout/ClassStructure
         include RuboCop::Cop::EnforceSuperclass
@@ -32,7 +36,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, self.class::SUPERCLASS)
+            corrector.replace(node, self.class::SUPERCLASS)
           end
         end
       end

data/lib/rubocop/cop/rails/application_mailer.rb

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that mailers subclass ApplicationMailer with Rails 5.0.
+      # Checks that mailers subclass `ApplicationMailer` with Rails 5.0.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationMailer`
+      #   sneak into a mailer that is not purposed to inherit logic common among other mailers.
       #
       # @example
       #
@@ -24,7 +28,7 @@ module RuboCop
 
         MSG = 'Mailers should subclass `ApplicationMailer`.'
         SUPERCLASS = 'ApplicationMailer'
-        BASE_PATTERN = '(const (const nil? :ActionMailer) :Base)'
+        BASE_PATTERN = '(const (const {nil? cbase} :ActionMailer) :Base)'
 
         # rubocop:disable Layout/ClassStructure
         include RuboCop::Cop::EnforceSuperclass

data/lib/rubocop/cop/rails/application_record.rb

@@ -3,7 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that models subclass ApplicationRecord with Rails 5.0.
+      # Checks that models subclass `ApplicationRecord` with Rails 5.0.
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may let the logic from `ApplicationRecord`
+      #   sneak into an Active Record model that is not purposed to inherit logic common among other
+      #   Active Record models.
       #
       # @example
       #
@@ -24,7 +29,7 @@ module RuboCop
 
         MSG = 'Models should subclass `ApplicationRecord`.'
         SUPERCLASS = 'ApplicationRecord'
-        BASE_PATTERN = '(const (const nil? :ActiveRecord) :Base)'
+        BASE_PATTERN = '(const (const {nil? cbase} :ActiveRecord) :Base)'
 
         # rubocop:disable Layout/ClassStructure
         include RuboCop::Cop::EnforceSuperclass

data/lib/rubocop/cop/rails/arel_star.rb

@@ -3,13 +3,19 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop prevents usage of `"*"` on an Arel::Table column reference.
+      # Prevents usage of `"*"` on an Arel::Table column reference.
       #
       # Using `arel_table["*"]` causes the outputted string to be a literal
       # quoted asterisk (e.g. <tt>`my_model`.`*`</tt>). This causes the
       # database to look for a column named <tt>`*`</tt> (or `"*"`) as opposed
       # to expanding the column list as one would likely expect.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it turns a quoted `*` into
+      #   an SQL `*`, unquoted. `*` is a valid column name in certain databases
+      #   supported by Rails, and even though it is usually a mistake,
+      #   it might denote legitimate access to a column named `*`.
+      #
       # @example
       #   # bad
       #   MyTable.arel_table["*"]
@@ -32,7 +38,7 @@ module RuboCop
           return unless (star = star_bracket?(node))
 
           add_offense(star) do |corrector|
-            corrector.replace(star.loc.expression, 'Arel.star')
+            corrector.replace(star, 'Arel.star')
           end
         end
       end

data/lib/rubocop/cop/rails/assert_not.rb

@@ -25,7 +25,7 @@ module RuboCop
           return unless offensive?(node)
 
           add_offense(node) do |corrector|
-            expression = node.loc.expression
+            expression = node.source_range
 
             corrector.replace(expression, corrected_source(expression.source))
           end

data/lib/rubocop/cop/rails/attribute_default_block_value.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for `attribute` class methods that specify a `:default` option
+      # Looks for `attribute` class methods that specify a `:default` option
       # which value is an array, string literal or method call without a block.
       # It will accept all other values, such as string, symbol, integer and float literals
       # as well as constants.

data/lib/rubocop/cop/rails/belongs_to.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for belongs_to associations where we control whether the
+      # Looks for belongs_to associations where we control whether the
       # association is required via the deprecated `required` option instead.
       #
       # Since Rails 5, belongs_to associations are required by default and this
@@ -47,9 +47,6 @@ module RuboCop
       #   class Post < ApplicationRecord
       #     belongs_to :blog, optional: false
       #   end
-      #
-      # @see https://guides.rubyonrails.org/5_0_release_notes.html
-      # @see https://github.com/rails/rails/pull/18937
       class BelongsTo < Base
         extend AutoCorrector
         extend TargetRailsVersion
@@ -83,7 +80,7 @@ module RuboCop
               end
 
             add_offense(node.loc.selector, message: message) do |corrector|
-              corrector.replace(option_node.loc.expression, replacement)
+              corrector.replace(option_node, replacement)
             end
           end
         end

data/lib/rubocop/cop/rails/blank.rb

@@ -3,17 +3,18 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for code that can be written with simpler conditionals
+      # Checks for code that can be written with simpler conditionals
       # using `Object#blank?` defined by Active Support.
       #
-      # This cop is marked as unsafe auto-correction, because `' '.empty?` returns false,
-      # but `' '.blank?` returns true. Therefore, auto-correction is not compatible
-      # if the receiver is a non-empty blank string, tab, or newline meta characters.
-      #
       # Interaction with `Style/UnlessElse`:
       # The configuration of `NotPresent` will not produce an offense in the
-      # context of `unless else` if `Style/UnlessElse` is inabled. This is
-      # to prevent interference between the auto-correction of the two cops.
+      # context of `unless else` if `Style/UnlessElse` is enabled. This is
+      # to prevent interference between the autocorrection of the two cops.
+      #
+      # @safety
+      #   This cop is unsafe autocorrection, because `' '.empty?` returns false,
+      #   but `' '.blank?` returns true. Therefore, autocorrection is not compatible
+      #   if the receiver is a non-empty blank string, tab, or newline meta characters.
       #
       # @example NilOrEmpty: true (default)
       #   # Converts usages of `nil? || empty?` to `blank?`
@@ -62,8 +63,7 @@ module RuboCop
 
         MSG_NIL_OR_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'
         MSG_NOT_PRESENT = 'Use `%<prefer>s` instead of `%<current>s`.'
-        MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of ' \
-                             '`%<current>s`.'
+        MSG_UNLESS_PRESENT = 'Use `if %<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[!].freeze
 
         # `(send nil $_)` is not actually a valid match for an offense. Nodes
@@ -142,10 +142,10 @@ module RuboCop
 
           if method_call
             corrector.replace(node.loc.keyword, 'if')
-            range = method_call.loc.expression
+            range = method_call.source_range
           else
             variable1, _variable2 = nil_or_empty?(node) || not_present?(node)
-            range = node.loc.expression
+            range = node.source_range
           end
 
           corrector.replace(range, replacement(variable1))
@@ -153,9 +153,9 @@ module RuboCop
 
         def unless_condition(node, method_call)
           if node.modifier_form?
-            node.loc.keyword.join(node.loc.expression.end)
+            node.loc.keyword.join(node.source_range.end)
           else
-            node.loc.expression.begin.join(method_call.loc.expression)
+            node.source_range.begin.join(method_call.source_range)
           end
         end
 

data/lib/rubocop/cop/rails/bulk_change_table.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This Cop checks whether alter queries are combinable.
+      # Checks whether alter queries are combinable.
       # If combinable queries are detected, it suggests to you
       # to use `change_table` with `bulk: true` instead.
       # This option causes the migration to generate a single
@@ -62,9 +62,6 @@ module RuboCop
       #       t.string :nickname
       #     end
       #   end
-      #
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/SchemaStatements.html#method-i-change_table
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/ConnectionAdapters/Table.html
       class BulkChangeTable < Base
         MSG_FOR_CHANGE_TABLE = <<~MSG.chomp
           You can combine alter queries using `bulk: true` options.
@@ -111,25 +108,13 @@ module RuboCop
           remove_timestamps
         ].freeze
 
-        MYSQL_COMBINABLE_TRANSFORMATIONS = %i[
-          rename
-          index
-          remove_index
-        ].freeze
+        MYSQL_COMBINABLE_TRANSFORMATIONS = %i[rename index remove_index].freeze
 
-        MYSQL_COMBINABLE_ALTER_METHODS = %i[
-          rename_column
-          add_index
-          remove_index
-        ].freeze
+        MYSQL_COMBINABLE_ALTER_METHODS = %i[rename_column add_index remove_index].freeze
 
-        POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[
-          change_default
-        ].freeze
+        POSTGRESQL_COMBINABLE_TRANSFORMATIONS = %i[change_default].freeze
 
-        POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[
-          change_column_default
-        ].freeze
+        POSTGRESQL_COMBINABLE_ALTER_METHODS = %i[change_column_default].freeze
 
         def on_def(node)
           return unless support_bulk_alter?
@@ -155,25 +140,38 @@ module RuboCop
           return if include_bulk_options?(node)
           return unless node.block_node
 
-          send_nodes = node.block_node.body.each_child_node(:send).to_a
-
-          transformations = send_nodes.select do |send_node|
-            combinable_transformations.include?(send_node.method_name)
-          end
+          send_nodes = send_nodes_from_change_table_block(node.block_node.body)
 
-          add_offense_for_change_table(node) if transformations.size > 1
+          add_offense_for_change_table(node) if count_transformations(send_nodes) > 1
         end
 
         private
 
+        def send_nodes_from_change_table_block(body)
+          if body.send_type?
+            [body]
+          else
+            body.each_child_node(:send).to_a
+          end
+        end
+
+        def count_transformations(send_nodes)
+          send_nodes.sum do |node|
+            if node.method?(:remove)
+              node.arguments.count { |arg| !arg.hash_type? }
+            else
+              combinable_transformations.include?(node.method_name) ? 1 : 0
+            end
+          end
+        end
+
         # @param node [RuboCop::AST::SendNode] (send nil? :change_table ...)
         def include_bulk_options?(node)
           # arguments: [{(sym :table)(str "table")} (hash (pair (sym :bulk) _))]
           options = node.arguments[1]
           return false unless options
 
-          options.hash_type? &&
-            options.keys.any? { |key| key.sym_type? && key.value == :bulk }
+          options.hash_type? && options.keys.any? { |key| key.sym_type? && key.value == :bulk }
         end
 
         def database
@@ -215,7 +213,7 @@ module RuboCop
             true
           when POSTGRESQL
             # Add bulk alter support for PostgreSQL in 5.2.0
-            # @see https://github.com/rails/rails/pull/31331
+            # See: https://github.com/rails/rails/pull/31331
             target_rails_version >= 5.2
           else
             false
@@ -223,8 +221,7 @@ module RuboCop
         end
 
         def call_to_combinable_alter_method?(child_node)
-          child_node.send_type? &&
-            combinable_alter_methods.include?(child_node.method_name)
+          child_node.send_type? && combinable_alter_methods.include?(child_node.method_name)
         end
 
         def combinable_alter_methods

data/lib/rubocop/cop/rails/compact_blank.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks if collection can be blank-compacted with `compact_blank`.
+      #
+      # @safety
+      #   It is unsafe by default because false positives may occur in the
+      #   blank check of block arguments to the receiver object.
+      #
+      #   For example, `[[1, 2], [3, nil]].reject { |first, second| second.blank? }` and
+      #   `[[1, 2], [3, nil]].compact_blank` are not compatible. The same is true for `blank?`.
+      #   This will work fine when the receiver is a hash object.
+      #
+      #   And `compact_blank!` has different implementations for `Array`, `Hash`, and
+      #   `ActionController::Parameters`.
+      #   `Array#compact_blank!`, `Hash#compact_blank!` are equivalent to `delete_if(&:blank?)`.
+      #   `ActionController::Parameters#compact_blank!` is equivalent to `reject!(&:blank?)`.
+      #   If the cop makes a mistake, autocorrected code may get unexpected behavior.
+      #
+      # @example
+      #
+      #   # bad
+      #   collection.reject(&:blank?)
+      #   collection.reject { |_k, v| v.blank? }
+      #
+      #   # good
+      #   collection.compact_blank
+      #
+      #   # bad
+      #   collection.delete_if(&:blank?)            # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      #   collection.delete_if { |_k, v| v.blank? } # Same behavior as `Array#compact_blank!` and `Hash#compact_blank!`
+      #   collection.reject!(&:blank?)              # Same behavior as `ActionController::Parameters#compact_blank!`
+      #   collection.reject! { |_k, v| v.blank? }   # Same behavior as `ActionController::Parameters#compact_blank!`
+      #
+      #   # good
+      #   collection.compact_blank!
+      #
+      class CompactBlank < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        MSG = 'Use `%<preferred_method>s` instead.'
+        RESTRICT_ON_SEND = %i[reject delete_if reject!].freeze
+
+        minimum_target_rails_version 6.1
+
+        def_node_matcher :reject_with_block?, <<~PATTERN
+          (block
+            (send _ {:reject :delete_if :reject!})
+            $(args ...)
+            (send
+              $(lvar _) :blank?))
+        PATTERN
+
+        def_node_matcher :reject_with_block_pass?, <<~PATTERN
+          (send _ {:reject :delete_if :reject!}
+            (block_pass
+              (sym :blank?)))
+        PATTERN
+
+        def on_send(node)
+          return unless bad_method?(node)
+
+          range = offense_range(node)
+          preferred_method = preferred_method(node)
+          add_offense(range, message: format(MSG, preferred_method: preferred_method)) do |corrector|
+            corrector.replace(range, preferred_method)
+          end
+        end
+
+        private
+
+        def bad_method?(node)
+          return true if reject_with_block_pass?(node)
+
+          if (arguments, receiver_in_block = reject_with_block?(node.parent))
+            return use_single_value_block_argument?(arguments, receiver_in_block) ||
+                   use_hash_value_block_argument?(arguments, receiver_in_block)
+          end
+
+          false
+        end
+
+        def use_single_value_block_argument?(arguments, receiver_in_block)
+          arguments.length == 1 && arguments[0].source == receiver_in_block.source
+        end
+
+        def use_hash_value_block_argument?(arguments, receiver_in_block)
+          arguments.length == 2 && arguments[1].source == receiver_in_block.source
+        end
+
+        def offense_range(node)
+          end_pos = if node.parent&.block_type? && node.parent&.send_node == node
+                      node.parent.source_range.end_pos
+                    else
+                      node.source_range.end_pos
+                    end
+
+          range_between(node.loc.selector.begin_pos, end_pos)
+        end
+
+        def preferred_method(node)
+          node.method?(:reject) ? 'compact_blank' : 'compact_blank!'
+        end
+      end
+    end
+  end
+end