rubocop-rails 2.14.2 → 2.19.1

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?
@@ -186,8 +171,7 @@ module RuboCop
           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
@@ -229,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
@@ -237,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

@@ -17,7 +17,7 @@ module RuboCop
       #   `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, auto-corrected code may get unexpected behavior.
+      #   If the cop makes a mistake, autocorrected code may get unexpected behavior.
       #
       # @example
       #
@@ -93,7 +93,11 @@ module RuboCop
         end
 
         def offense_range(node)
-          end_pos = node.parent&.block_type? ? node.parent.loc.expression.end_pos : node.loc.expression.end_pos
+          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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks legacy syntax usage of `tag`
+      # Checks legacy syntax usage of `tag`
       #
       # NOTE: Allow `tag` when the first argument is a variable because
       # `tag(name)` is simpler rather than `tag.public_send(name)`.
@@ -37,9 +37,7 @@ module RuboCop
           return if node.arguments.count >= 3
 
           first_argument = node.first_argument
-          return if !first_argument ||
-                    allowed_argument?(first_argument) ||
-                    corrected_ancestor?(node)
+          return if !first_argument || allowed_argument?(first_argument) || corrected_ancestor?(node)
 
           preferred_method = node.first_argument.value.to_s.underscore
           message = format(MSG, preferred_method: preferred_method, current_argument: first_argument.source)
@@ -58,7 +56,8 @@ module RuboCop
             argument.send_type? ||
             argument.const_type? ||
             argument.splat_type? ||
-            allowed_name?(argument)
+            allowed_name?(argument) ||
+            !argument.respond_to?(:value)
         end
 
         def register_offense(node, message, preferred_method)
@@ -82,11 +81,11 @@ module RuboCop
         def allowed_name?(argument)
           return false unless argument.str_type? || argument.sym_type?
 
-          !/^[a-zA-Z\-][a-zA-Z\-0-9]*$/.match?(argument.value)
+          !/^[a-zA-Z-][a-zA-Z\-0-9]*$/.match?(argument.value)
         end
 
         def correction_range(node)
-          range_between(node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
         end
       end
     end

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

@@ -3,10 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks the migration for which timestamps are not included
-      # when creating a new table.
+      # Checks the migration for which timestamps are not included when creating a new table.
       # In many cases, timestamps are useful information and should be added.
       #
+      # NOTE: Allow `timestamps` not written when `id: false` because this emphasizes respecting
+      # user's editing intentions.
+      #
       # @example
       #   # bad
       #   create_table :users
@@ -40,12 +42,23 @@ module RuboCop
       #
       #     t.datetime :updated_at, default: -> { 'CURRENT_TIMESTAMP' }
       #   end
+      #
+      #   # good
+      #   create_table :users, articles, id: false do |t|
+      #     t.integer :user_id
+      #     t.integer :article_id
+      #   end
+      #
       class CreateTableWithTimestamps < Base
         include ActiveRecordMigrationsHelper
 
         MSG = 'Add timestamps when creating a new table.'
         RESTRICT_ON_SEND = %i[create_table].freeze
 
+        def_node_search :use_id_false_option?, <<~PATTERN
+          (pair (sym :id) (false))
+        PATTERN
+
         def_node_matcher :create_table_with_timestamps_proc?, <<~PATTERN
           (send nil? :create_table (sym _) ... (block-pass (sym :timestamps)))
         PATTERN
@@ -61,7 +74,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return unless node.command?(:create_table)
+          return if !node.command?(:create_table) || use_id_false_option?(node)
 
           parent = node.parent
 

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for the correct use of Date methods,
+      # Checks for the correct use of Date methods,
       # such as Date.today, Date.current etc.
       #
       # Using `Date.today` is dangerous, because it doesn't know anything about
@@ -22,26 +22,26 @@ module RuboCop
       # And you can set a warning for `to_time` with `AllowToTime: false`.
       # `AllowToTime` is `true` by default to prevent false positive on `DateTime` object.
       #
-      # @example EnforcedStyle: strict
+      # @example EnforcedStyle: flexible (default)
       #   # bad
-      #   Date.current
-      #   Date.yesterday
       #   Date.today
       #
       #   # good
       #   Time.zone.today
       #   Time.zone.today - 1.day
+      #   Date.current
+      #   Date.yesterday
+      #   date.in_time_zone
       #
-      # @example EnforcedStyle: flexible (default)
+      # @example EnforcedStyle: strict
       #   # bad
+      #   Date.current
+      #   Date.yesterday
       #   Date.today
       #
       #   # good
       #   Time.zone.today
       #   Time.zone.today - 1.day
-      #   Date.current
-      #   Date.yesterday
-      #   date.in_time_zone
       #
       # @example AllowToTime: true (default)
       #   # good
@@ -53,22 +53,17 @@ module RuboCop
       class Date < Base
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `Date.%<method_called>s` without zone. Use ' \
-              '`Time.zone.%<day>s` instead.'
+        MSG = 'Do not use `Date.%<method_called>s` without zone. Use `Time.zone.%<day>s` instead.'
 
-        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they ' \
-                   'know nothing about the time zone in use.'
+        MSG_SEND = 'Do not use `%<method>s` on Date objects, because they know nothing about the time zone in use.'
 
         RESTRICT_ON_SEND = %i[to_time to_time_in_current_zone].freeze
 
         BAD_DAYS = %i[today current yesterday tomorrow].freeze
 
-        DEPRECATED_METHODS = [
-          { deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }
-        ].freeze
+        DEPRECATED_METHODS = [{ deprecated: 'to_time_in_current_zone', relevant: 'in_time_zone' }].freeze
 
-        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. ' \
-                         'Use `%<relevant>s` instead.'
+        DEPRECATED_MSG = '`%<deprecated>s` is deprecated. Use `%<relevant>s` instead.'
 
         def on_const(node)
           mod, klass = *node.children

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for uses of `default_scope`.
+      # Looks for uses of `default_scope`.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations that could have been created
+      # Looks for delegations that could have been created
       # automatically with the `delegate` method.
       #
       # Safe navigation `&.` is ignored because Rails' `allow_nil`
@@ -24,6 +24,14 @@ module RuboCop
       #   # good
       #   delegate :bar, to: :foo
       #
+      #   # bad
+      #   def bar
+      #     self.bar
+      #   end
+      #
+      #   # good
+      #   delegate :bar, to: :self
+      #
       #   # good
       #   def bar
       #     foo&.bar
@@ -54,12 +62,13 @@ module RuboCop
       #   delegate :bar, to: :foo, prefix: true
       class Delegate < Base
         extend AutoCorrector
+        include VisibilityHelp
 
         MSG = 'Use `delegate` to define delegations.'
 
         def_node_matcher :delegate?, <<~PATTERN
           (def _method_name _args
-            (send (send nil? _) _ ...))
+            (send {(send nil? _) (self)} _ ...))
         PATTERN
 
         def on_def(node)
@@ -73,10 +82,14 @@ module RuboCop
 
         def register_offense(node)
           add_offense(node.loc.keyword) do |corrector|
-            delegation = ["delegate :#{node.body.method_name}", "to: :#{node.body.receiver.method_name}"]
+            body = node.body
+
+            receiver = body.receiver.self_type? ? 'self' : ":#{body.receiver.method_name}"
+
+            delegation = ["delegate :#{body.method_name}", "to: #{receiver}"]
             delegation << ['prefix: true'] if node.method?(prefixed_method_name(node.body))
 
-            corrector.replace(node.source_range, delegation.join(', '))
+            corrector.replace(node, delegation.join(', '))
           end
         end
 
@@ -92,15 +105,12 @@ module RuboCop
           return false if arg_array.size != argument_array.size
 
           arg_array.zip(argument_array).all? do |arg, argument|
-            arg.arg_type? &&
-              argument.lvar_type? &&
-              arg.children == argument.children
+            arg.arg_type? && argument.lvar_type? && arg.children == argument.children
           end
         end
 
         def method_name_matches?(method_name, body)
-          method_name == body.method_name ||
-            (include_prefix_case? && method_name == prefixed_method_name(body))
+          method_name == body.method_name || (include_prefix_case? && method_name == prefixed_method_name(body))
         end
 
         def include_prefix_case?
@@ -108,21 +118,17 @@ module RuboCop
         end
 
         def prefixed_method_name(body)
+          return '' if body.receiver.self_type?
+
           [body.receiver.method_name, body.method_name].join('_').to_sym
         end
 
         def private_or_protected_delegation(node)
-          line = node.first_line
-          private_or_protected_before(line) ||
-            private_or_protected_inline(line)
-        end
-
-        def private_or_protected_before(line)
-          (processed_source[0..line].map(&:strip) & %w[private protected]).any?
+          private_or_protected_inline(node) || node_visibility(node) != :public
         end
 
-        def private_or_protected_inline(line)
-          processed_source[line - 1].strip.match?(/\A(private )|(protected )/)
+        def private_or_protected_inline(node)
+          processed_source[node.first_line - 1].strip.match?(/\A(private )|(protected )/)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for delegations that pass :allow_blank as an option
+      # Looks for delegations that pass :allow_blank as an option
       # instead of :allow_nil. :allow_blank is not a valid option to pass
       # to ActiveSupport#delegate.
       #
@@ -27,7 +27,7 @@ module RuboCop
           return unless (offending_node = allow_blank_option(node))
 
           add_offense(offending_node) do |corrector|
-            corrector.replace(offending_node.key.source_range, 'allow_nil')
+            corrector.replace(offending_node.key, 'allow_nil')
           end
         end
       end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks direct manipulation of ActiveModel#errors as hash.
+      # Checks direct manipulation of ActiveModel#errors as hash.
       # These operations are deprecated in Rails 6.1 and will not work in Rails 7.
       #
       # @safety
@@ -26,8 +26,19 @@ module RuboCop
       #   # good
       #   user.errors.delete(:name)
       #
+      #   # bad
+      #   user.errors.keys.include?(:attr)
+      #
+      #   # good
+      #   user.errors.attribute_names.include?(:attr)
+      #
       class DeprecatedActiveModelErrorsMethods < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Avoid manipulating ActiveModel errors as hash directly.'
+        AUTOCORRECTABLE_METHODS = %i[<< clear keys].freeze
+        INCOMPATIBLE_METHODS = %i[keys values to_h to_xml].freeze
 
         MANIPULATIVE_METHODS = Set[
           *%i[
@@ -45,6 +56,7 @@ module RuboCop
           {
             #root_manipulation?
             #root_assignment?
+            #errors_deprecated?
             #messages_details_manipulation?
             #messages_details_assignment?
           }
@@ -66,6 +78,12 @@ module RuboCop
             ...)
         PATTERN
 
+        def_node_matcher :errors_deprecated?, <<~PATTERN
+          (send
+            (send #receiver_matcher :errors)
+            {:keys :values :to_h :to_xml})
+        PATTERN
+
         def_node_matcher :messages_details_manipulation?, <<~PATTERN
           (send
             (send
@@ -89,18 +107,60 @@ module RuboCop
 
         def on_send(node)
           any_manipulation?(node) do
-            add_offense(node)
+            next if target_rails_version <= 6.0 && INCOMPATIBLE_METHODS.include?(node.method_name)
+
+            add_offense(node) do |corrector|
+              next if skip_autocorrect?(node)
+
+              autocorrect(corrector, node)
+            end
           end
         end
 
         private
 
+        def skip_autocorrect?(node)
+          return true unless AUTOCORRECTABLE_METHODS.include?(node.method_name)
+          return false unless (receiver = node.receiver.receiver)
+
+          receiver.send_type? && receiver.method?(:details) && node.method?(:<<)
+        end
+
+        def autocorrect(corrector, node)
+          receiver = node.receiver
+
+          range = offense_range(node, receiver)
+          replacement = replacement(node, receiver)
+
+          corrector.replace(range, replacement)
+        end
+
+        def offense_range(node, receiver)
+          receiver = receiver.receiver while receiver.send_type? && !receiver.method?(:errors) && receiver.receiver
+          range_between(receiver.source_range.end_pos, node.source_range.end_pos)
+        end
+
+        def replacement(node, receiver)
+          return '.attribute_names' if node.method?(:keys)
+
+          key = receiver.first_argument.source
+
+          case node.method_name
+          when :<<
+            value = node.first_argument.source
+
+            ".add(#{key}, #{value})"
+          when :clear
+            ".delete(#{key})"
+          end
+        end
+
         def receiver_matcher(node)
           model_file? ? receiver_matcher_inside_model(node) : receiver_matcher_outside_model(node)
         end
 
         def model_file?
-          processed_source.buffer.name.include?('/models/')
+          processed_source.file_path.include?('/models/')
         end
       end
     end

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

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces the use of dot-separated locale keys instead of specifying the `:scope` option
+      # with an array or a single symbol in `I18n` translation methods.
+      # Dot-separated notation is easier to read and trace the hierarchy.
+      #
+      # @example
+      #   # bad
+      #   I18n.t :record_invalid, scope: [:activerecord, :errors, :messages]
+      #   I18n.t :title, scope: :invitation
+      #
+      #   # good
+      #   I18n.t 'activerecord.errors.messages.record_invalid'
+      #   I18n.t :record_invalid, scope: 'activerecord.errors.messages'
+      #
+      class DotSeparatedKeys < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use the dot-separated keys instead of specifying the `:scope` option.'
+        TRANSLATE_METHODS = %i[translate t].freeze
+
+        def_node_matcher :translate_with_scope?, <<~PATTERN
+          (send {nil? (const {nil? cbase} :I18n)} {:translate :t} ${sym_type? str_type?}
+            (hash <$(pair (sym :scope) ${array_type? sym_type?}) ...>)
+          )
+        PATTERN
+
+        def on_send(node)
+          return unless TRANSLATE_METHODS.include?(node.method_name)
+
+          translate_with_scope?(node) do |key_node, scope_node|
+            return unless should_convert_scope?(scope_node)
+
+            add_offense(scope_node) do |corrector|
+              # Eat the comma on the left.
+              range = range_with_surrounding_space(scope_node.source_range, side: :left)
+              range = range_with_surrounding_comma(range, :left)
+              corrector.remove(range)
+
+              corrector.replace(key_node, new_key(key_node, scope_node))
+            end
+          end
+        end
+
+        private
+
+        def should_convert_scope?(scope_node)
+          scopes(scope_node).all?(&:basic_literal?)
+        end
+
+        def new_key(key_node, scope_node)
+          "'#{scopes(scope_node).map(&:value).join('.')}.#{key_node.value}'".squeeze('.')
+        end
+
+        def scopes(scope_node)
+          value = scope_node.value
+
+          if value.array_type?
+            value.values
+          else
+            [value]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop looks for associations that have been defined multiple times in the same file.
+      # Looks for associations that have been defined multiple times in the same file.
       #
       # When an association is defined multiple times on a model, Active Record overrides the
       # previously defined association with the new one. Because of this, this cop's autocorrection
@@ -35,7 +35,7 @@ module RuboCop
           offenses(class_node).each do |name, nodes|
             nodes.each do |node|
               add_offense(node, message: format(MSG, name: name)) do |corrector|
-                next if nodes.last == node
+                next if same_line?(nodes.last, node)
 
                 corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
               end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks for multiple scopes in a model that have the same `where` clause. This
+      # Checks for multiple scopes in a model that have the same `where` clause. This
       # often means you copy/pasted a scope, updated the name, and forgot to change the condition.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # This cop checks if a duration is added to or subtracted from `Time.current`.
+      # Checks if a duration is added to or subtracted from `Time.current`.
       #
       # @example
       #   # bad
@@ -70,15 +70,15 @@ module RuboCop
         #   @return [Boolean] true if matches
         def_node_matcher :time_current?, <<~PATTERN
           {
-            (send (const _ :Time) :current)
-            (send (send (const _ :Time) :zone) :now)
+            (send (const {nil? cbase} :Time) :current)
+            (send (send (const {nil? cbase} :Time) :zone) :now)
           }
         PATTERN
 
         def on_send(node)
           duration_arithmetic_argument?(node) do |*operation|
             add_offense(node) do |corrector|
-              corrector.replace(node.source_range, corrected_source(*operation))
+              corrector.replace(node, corrected_source(*operation))
             end
           end
         end