rubocop-rails 2.11.2 → 2.19.1

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that `if` and `only` (or `except`) are not used together
+      # Checks that `if` and `only` (or `except`) are not used together
       # as options of `skip_*` action filter.
       #
       # The `if` option will be ignored when `if` and `only` are used together.
@@ -35,19 +35,12 @@ module RuboCop
       #     skip_before_action :login_required,
       #       if: -> { trusted_origin? && action_name != "admin" }
       #   end
-      #
-      # @see https://api.rubyonrails.org/classes/AbstractController/Callbacks/ClassMethods.html#method-i-_normalize_callback_options
       class IgnoredSkipActionFilterOption < Base
         MSG = <<~MSG.chomp.freeze
           `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
         MSG
 
-        RESTRICT_ON_SEND = %i[
-          skip_after_action
-          skip_around_action
-          skip_before_action
-          skip_action_callback
-        ].freeze
+        RESTRICT_ON_SEND = %i[skip_after_action skip_around_action skip_before_action skip_action_callback].freeze
 
         FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
 
@@ -67,11 +60,9 @@ module RuboCop
           options = options_hash(options)
 
           if if_and_only?(options)
-            add_offense(options[:if],
-                        message: format(MSG, prefer: :only, ignore: :if))
+            add_offense(options[:if], message: format(MSG, prefer: :only, ignore: :if))
           elsif if_and_except?(options)
-            add_offense(options[:except],
-                        message: format(MSG, prefer: :if, ignore: :except))
+            add_offense(options[:except], message: format(MSG, prefer: :if, ignore: :except))
           end
         end
 
@@ -80,7 +71,7 @@ module RuboCop
         def options_hash(options)
           options.pairs
                  .select { |pair| pair.key.sym_type? }
-                 .map { |pair| [pair.key.value, pair] }.to_h
+                 .to_h { |pair| [pair.key.value, pair] }
         end
 
         def if_and_only?(options)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for uses of `each_with_object({}) { ... }`,
+      # Looks for uses of `each_with_object({}) { ... }`,
       # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
       # an enumerable into a hash where the values are the original elements.
       # Rails provides the `index_by` method for this purpose.
@@ -23,22 +23,22 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} _ :each_with_object (hash))
+            (call _ :each_with_object (hash))
             (args (arg $_el) (arg _memo))
-            ({send csend} (lvar _memo) :[]= $!`_memo (lvar _el)))
+            (call (lvar _memo) :[]= $!`_memo (lvar _el)))
         PATTERN
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend} _ :to_h)
+            (call _ :to_h)
             (args (arg $_el))
             (array $_ (lvar _el)))
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          ({send csend}
+          (call
             (block
-              ({send csend} _ {:map :collect})
+              (call _ {:map :collect})
               (args (arg $_el))
               (array $_ (lvar _el)))
             :to_h)
@@ -46,10 +46,10 @@ module RuboCop
 
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
-            (const _ :Hash)
+            (const {nil? cbase} :Hash)
             :[]
             (block
-              ({send csend} _ {:map :collect})
+              (call _ {:map :collect})
               (args (arg $_el))
               (array $_ (lvar _el))))
         PATTERN

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for uses of `each_with_object({}) { ... }`,
+      # Looks for uses of `each_with_object({}) { ... }`,
       # `map { ... }.to_h`, and `Hash[map { ... }]` that are transforming
       # an enumerable into a hash where the keys are the original elements.
       # Rails provides the `index_with` method for this purpose.
@@ -26,22 +26,22 @@ module RuboCop
 
         def_node_matcher :on_bad_each_with_object, <<~PATTERN
           (block
-            ({send csend} _ :each_with_object (hash))
+            (call _ :each_with_object (hash))
             (args (arg $_el) (arg _memo))
-            ({send csend} (lvar _memo) :[]= (lvar _el) $!`_memo))
+            (call (lvar _memo) :[]= (lvar _el) $!`_memo))
         PATTERN
 
         def_node_matcher :on_bad_to_h, <<~PATTERN
           (block
-            ({send csend} _ :to_h)
+            (call _ :to_h)
             (args (arg $_el))
             (array (lvar _el) $_))
         PATTERN
 
         def_node_matcher :on_bad_map_to_h, <<~PATTERN
-          ({send csend}
+          (call
             (block
-              ({send csend} _ {:map :collect})
+              (call _ {:map :collect})
               (args (arg $_el))
               (array (lvar _el) $_))
             :to_h)
@@ -49,10 +49,10 @@ module RuboCop
 
         def_node_matcher :on_bad_hash_brackets_map, <<~PATTERN
           (send
-            (const _ :Hash)
+            (const {nil? cbase} :Hash)
             :[]
             (block
-              ({send csend} _ {:map :collect})
+              (call _ {:map :collect})
               (args (arg $_el))
               (array (lvar _el) $_)))
         PATTERN

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that Active Support's `inquiry` method is not used.
+      # Checks that Active Support's `inquiry` method is not used.
       #
       # @example
       #   # bad - String#inquiry

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for has_(one|many) and belongs_to associations where
+      # Looks for has_(one|many) and belongs_to associations where
       # Active Record can't automatically determine the inverse association
       # because of a scope or the options used. Using the blog with order scope
       # example below, traversing the a Blog's association in both directions
@@ -126,8 +126,17 @@ module RuboCop
       #     has_many :physicians, through: :appointments
       #   end
       #
-      # @see https://guides.rubyonrails.org/association_basics.html#bi-directional-associations
-      # @see https://api.rubyonrails.org/classes/ActiveRecord/Associations/ClassMethods.html#module-ActiveRecord::Associations::ClassMethods-label-Setting+Inverses
+      # @example IgnoreScopes: false (default)
+      #   # bad
+      #   class Blog < ApplicationRecord
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
+      #
+      # @example IgnoreScopes: true
+      #   # good
+      #   class Blog < ApplicationRecord
+      #     has_many :posts, -> { order(published_at: :desc) }
+      #   end
       class InverseOf < Base
         SPECIFY_MSG = 'Specify an `:inverse_of` option.'
         NIL_MSG = 'You specified `inverse_of: nil`, you probably meant to use `inverse_of: false`.'
@@ -180,8 +189,7 @@ module RuboCop
           end
           return if options_ignoring_inverse_of?(options)
 
-          return unless scope?(arguments) ||
-                        options_requiring_inverse_of?(options)
+          return unless scope?(arguments) || options_requiring_inverse_of?(options)
 
           return if options_contain_inverse_of?(options)
 
@@ -189,13 +197,12 @@ module RuboCop
         end
 
         def scope?(arguments)
-          arguments.any?(&:block_type?)
+          !ignore_scopes? && arguments.any?(&:block_type?)
         end
 
         def options_requiring_inverse_of?(options)
           required = options.any? do |opt|
-            conditions_option?(opt) ||
-              foreign_key_option?(opt)
+            conditions_option?(opt) || foreign_key_option?(opt)
           end
 
           return required if target_rails_version >= 5.2
@@ -215,8 +222,7 @@ module RuboCop
 
         def with_options_arguments(recv, node)
           blocks = node.each_ancestor(:block).select do |block|
-            block.send_node.command?(:with_options) &&
-              same_context_in_with_options?(block.arguments.first, recv)
+            block.send_node.command?(:with_options) && same_context_in_with_options?(block.arguments.first, recv)
           end
           blocks.flat_map { |n| n.send_node.arguments }
         end
@@ -236,6 +242,10 @@ module RuboCop
             SPECIFY_MSG
           end
         end
+
+        def ignore_scopes?
+          cop_config['IgnoreScopes'] == true
+        end
       end
     end
   end

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

@@ -3,16 +3,17 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks that methods specified in the filter's `only` or
+      # Checks that methods specified in the filter's `only` or
       # `except` options are defined within the same class or module.
       #
-      # You can technically specify methods of superclass or methods added by
-      # mixins on the filter, but these can confuse developers. If you specify
-      # methods that are defined in other classes or modules, you should
-      # define the filter in that class or module.
+      # @safety
+      #   You can technically specify methods of superclass or methods added by
+      #   mixins on the filter, but these can confuse developers. If you specify
+      #   methods that are defined in other classes or modules, you should
+      #   define the filter in that class or module.
       #
-      # If you rely on behaviour defined in the superclass actions, you must
-      # remember to invoke `super` in the subclass actions.
+      #   If you rely on behavior defined in the superclass actions, you must
+      #   remember to invoke `super` in the subclass actions.
       #
       # @example
       #   # bad
@@ -70,7 +71,7 @@ module RuboCop
       #   class ArticlesController < ContentController
       #     before_action :load_article, only: [:update]
       #
-      #     # the cop requires this method, but it relies on behaviour defined
+      #     # the cop requires this method, but it relies on behavior defined
       #     # in the superclass, so needs to invoke `super`
       #     def update
       #       super
@@ -124,9 +125,10 @@ module RuboCop
           block = parent.each_child_node(:begin).first
           return unless block
 
-          defined_methods = block.each_child_node(:def).map(&:method_name)
+          defined_action_methods = defined_action_methods(block)
+
           methods = array_values(methods_node).reject do |method|
-            defined_methods.include?(method)
+            defined_action_methods.include?(method)
           end
 
           message = message(methods, parent)
@@ -135,6 +137,36 @@ module RuboCop
 
         private
 
+        def defined_action_methods(block)
+          defined_methods = block.each_child_node(:def).map(&:method_name)
+
+          defined_methods + aliased_action_methods(block, defined_methods)
+        end
+
+        def aliased_action_methods(node, defined_methods)
+          alias_methods = alias_methods(node)
+          defined_methods.each_with_object([]) do |defined_method, aliased_method|
+            if (new_method_name = alias_methods[defined_method])
+              aliased_method << new_method_name
+            end
+          end
+        end
+
+        def alias_methods(node)
+          result = {}
+          node.each_child_node(:send, :alias) do |child_node|
+            case child_node.type
+            when :send
+              if child_node.method?(:alias_method)
+                result[child_node.last_argument.value] = child_node.first_argument.value
+              end
+            when :alias
+              result[child_node.old_identifier.value] = child_node.new_identifier.value
+            end
+          end
+          result
+        end
+
         # @param node [RuboCop::AST::Node]
         # @return [Array<Symbol>]
         def array_values(node) # rubocop:disable Metrics/MethodLength
@@ -162,13 +194,9 @@ module RuboCop
         # @return [String]
         def message(methods, parent)
           if methods.size == 1
-            format(MSG,
-                   action: "`#{methods[0]}` is",
-                   type: parent.type)
+            format(MSG, action: "`#{methods[0]}` is", type: parent.type)
           else
-            format(MSG,
-                   action: "`#{methods.join('`, `')}` are",
-                   type: parent.type)
+            format(MSG, action: "`#{methods.join('`, `')}` are", type: parent.type)
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for calls to `link_to` that contain a
+      # Checks for calls to `link_to` that contain a
       # `target: '_blank'` but no `rel: 'noopener'`. This can be a security
       # risk as the loaded page will have control over the previous page
       # and could change its location for phishing purposes.
@@ -68,15 +68,12 @@ module RuboCop
 
         def append_to_rel(rel_node, corrector)
           existing_rel = rel_node.children.last.value
-          str_range = rel_node.children.last.loc.expression.adjust(
-            begin_pos: 1,
-            end_pos: -1
-          )
+          str_range = rel_node.children.last.source_range.adjust(begin_pos: 1, end_pos: -1)
           corrector.replace(str_range, "#{existing_rel} noopener")
         end
 
-        def add_rel(send_node, offence_node, corrector)
-          opening_quote = offence_node.children.last.source[0]
+        def add_rel(send_node, offense_node, corrector)
+          opening_quote = offense_node.children.last.source[0]
           closing_quote = opening_quote == ':' ? '' : opening_quote
           new_rel_exp = ", rel: #{opening_quote}noopener#{closing_quote}"
           range = if (last_argument = send_node.last_argument).hash_type?

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

@@ -3,11 +3,15 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces that mailer names end with `Mailer` suffix.
+      # Enforces that mailer names end with `Mailer` suffix.
       #
       # Without the `Mailer` suffix it isn't immediately apparent what's a mailer
       # and which views are related to the mailer.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because renaming a constant is
+      #   always an unsafe operation.
+      #
       # @example
       #   # bad
       #   class User < ActionMailer::Base
@@ -30,8 +34,8 @@ module RuboCop
 
         def_node_matcher :mailer_base_class?, <<~PATTERN
           {
-            (const (const nil? :ActionMailer) :Base)
-            (const nil? :ApplicationMailer)
+            (const (const {nil? cbase} :ActionMailer) :Base)
+            (const {nil? cbase} :ApplicationMailer)
           }
         PATTERN
 
@@ -40,7 +44,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :class_new_definition?, <<~PATTERN
-          (send (const nil? :Class) :new #mailer_base_class?)
+          (send (const {nil? cbase} :Class) :new #mailer_base_class?)
         PATTERN
 
         def on_class(node)
@@ -73,7 +77,7 @@ module RuboCop
             corrector.replace(node.loc.name, "#{name}Mailer")
           else
             name = node.children.last
-            corrector.replace(node.source_range, "#{name}Mailer")
+            corrector.replace(node, "#{name}Mailer")
           end
         end
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop identifies places where defining routes with `match`
+      # Identifies places where defining routes with `match`
       # can be replaced with a specific HTTP method.
       #
       # Don't use `match` to define any routes unless there is a need to map multiple request types

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Makes sure that each migration file defines a migration class
+      # whose name matches the file name.
+      # (e.g. `20220224111111_create_users.rb` should define `CreateUsers` class.)
+      #
+      # @example
+      #   # db/migrate/20220224111111_create_users.rb
+      #
+      #   # bad
+      #   class SellBooks < ActiveRecord::Migration[7.0]
+      #   end
+      #
+      #   # good
+      #   class CreateUsers < ActiveRecord::Migration[7.0]
+      #   end
+      #
+      class MigrationClassName < Base
+        extend AutoCorrector
+        include MigrationsHelper
+
+        MSG = 'Replace with `%<camelized_basename>s` that matches the file name.'
+
+        def on_class(node)
+          return unless migration_class?(node)
+
+          basename = basename_without_timestamp_and_suffix(processed_source.file_path)
+
+          class_identifier = node.identifier.location.name
+          camelized_basename = camelize(basename)
+          return if class_identifier.source.casecmp(camelized_basename).zero?
+
+          message = format(MSG, camelized_basename: camelized_basename)
+
+          add_offense(class_identifier, message: message) do |corrector|
+            corrector.replace(class_identifier, camelized_basename)
+          end
+        end
+
+        private
+
+        def basename_without_timestamp_and_suffix(filepath)
+          basename = File.basename(filepath, '.rb')
+          basename = remove_gem_suffix(basename)
+
+          basename.sub(/\A\d+_/, '')
+        end
+
+        # e.g.: from `add_blobs.active_storage` to `add_blobs`.
+        def remove_gem_suffix(file_name)
+          file_name.sub(/\..+\z/, '')
+        end
+
+        def camelize(word)
+          word.split('_').map(&:capitalize).join
+        end
+      end
+    end
+  end
+end

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

@@ -3,11 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop enforces the use of `collection.exclude?(obj)`
+      # Enforces the use of `collection.exclude?(obj)`
       # over `!collection.include?(obj)`.
       #
-      # It is marked as unsafe by default because false positive will occur for
-      # a receiver object that do not have `exclude?` method. (e.g. `IPAddr`)
+      # @safety
+      #   This cop is unsafe because false positive will occur for
+      #   receiver objects that do not have an `exclude?` method. (e.g. `IPAddr`)
       #
       # @example
       #   # bad
@@ -25,7 +26,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :negate_include_call?, <<~PATTERN
-          (send (send $_ :include? $_) :!)
+          (send (send $!nil? :include? $_) :!)
         PATTERN
 
         def on_send(node)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for add_column call with NOT NULL constraint
+      # Checks for add_column call with NOT NULL constraint
       # in migration file.
       #
       # @example
@@ -21,7 +21,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[add_column add_reference].freeze
 
         def_node_matcher :add_not_null_column?, <<~PATTERN
-          (send nil? :add_column _ _ _ (hash $...))
+          (send nil? :add_column _ _ $_ (hash $...))
         PATTERN
 
         def_node_matcher :add_not_null_reference?, <<~PATTERN
@@ -44,17 +44,20 @@ module RuboCop
         private
 
         def check_add_column(node)
-          pairs = add_not_null_column?(node)
-          check_pairs(pairs)
+          add_not_null_column?(node) do |type, pairs|
+            return if type.value == :virtual || type.value == 'virtual'
+
+            check_pairs(pairs)
+          end
         end
 
         def check_add_reference(node)
-          pairs = add_not_null_reference?(node)
-          check_pairs(pairs)
+          add_not_null_reference?(node) do |pairs|
+            check_pairs(pairs)
+          end
         end
 
         def check_pairs(pairs)
-          return unless pairs
           return if pairs.any? { |pair| default_option?(pair) }
 
           null_false = pairs.find { |pair| null_false?(pair) }

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for places where ordering by `id` column is used.
+      # Checks for places where ordering by `id` column is used.
       #
       # Don't use the `id` column for ordering. The sequence of ids is not guaranteed
       # to be in any particular order, despite often (incidentally) being chronological.
@@ -23,8 +23,7 @@ module RuboCop
       class OrderById < Base
         include RangeHelp
 
-        MSG = 'Do not use the `id` column for ordering. '\
-              'Use a timestamp column to order chronologically.'
+        MSG = 'Do not use the `id` column for ordering. Use a timestamp column to order chronologically.'
         RESTRICT_ON_SEND = %i[order].freeze
 
         def_node_matcher :order_by_id?, <<~PATTERN

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

@@ -3,7 +3,11 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of output calls like puts and print
+      # Checks for the use of output calls like puts and print
+      #
+      # @safety
+      #   This cop's autocorrection is unsafe because depending on the Rails log level configuration,
+      #   changing from `puts` to `Rails.logger.debug` could result in no output being shown.
       #
       # @example
       #   # bad
@@ -14,11 +18,11 @@ module RuboCop
       #   # good
       #   Rails.logger.debug 'A debug message'
       class Output < Base
-        MSG = 'Do not write to stdout. ' \
-              "Use Rails's logger if you want to log."
-        RESTRICT_ON_SEND = %i[
-          ap p pp pretty_print print puts binwrite syswrite write write_nonblock
-        ].freeze
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = "Do not write to stdout. Use Rails's logger if you want to log."
+        RESTRICT_ON_SEND = %i[ap p pp pretty_print print puts binwrite syswrite write write_nonblock].freeze
 
         def_node_matcher :output?, <<~PATTERN
           (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
@@ -28,17 +32,21 @@ module RuboCop
           (send
             {
               (gvar #match_gvar?)
-              {(const nil? :STDOUT) (const nil? :STDERR)}
+              (const {nil? cbase} {:STDOUT :STDERR})
             }
             {:binwrite :syswrite :write :write_nonblock}
             ...)
         PATTERN
 
         def on_send(node)
-          return unless (output?(node) || io_output?(node)) &&
-                        node.arguments?
+          return if node.parent&.call_type?
+          return unless output?(node) || io_output?(node)
+
+          range = offense_range(node)
 
-          add_offense(node.loc.selector)
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'Rails.logger.debug')
+          end
         end
 
         private
@@ -46,6 +54,14 @@ module RuboCop
         def match_gvar?(sym)
           %i[$stdout $stderr].include?(sym)
         end
+
+        def offense_range(node)
+          if node.receiver
+            range_between(node.source_range.begin_pos, node.loc.selector.end_pos)
+          else
+            node.loc.selector
+          end
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the use of output safety calls like `html_safe`,
+      # Checks for the use of output safety calls like `html_safe`,
       # `raw`, and `safe_concat`. These methods do not escape content. They
       # simply return a SafeBuffer containing the content as is. Instead,
       # use `safe_join` to join content and escape it and concat to
@@ -66,8 +66,12 @@ module RuboCop
         MSG = 'Tagging a string as html safe may be a security risk.'
         RESTRICT_ON_SEND = %i[html_safe raw safe_concat].freeze
 
+        def_node_search :i18n_method?, <<~PATTERN
+          (send {nil? (const {nil? cbase} :I18n)} {:t :translate :l :localize} ...)
+        PATTERN
+
         def on_send(node)
-          return if non_interpolated_string?(node)
+          return if non_interpolated_string?(node) || i18n_method?(node)
 
           return unless looks_like_rails_html_safe?(node) ||
                         looks_like_rails_raw?(node) ||