rubocop-rails 2.15.2 → 2.20.2

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

@@ -3,10 +3,12 @@
 module RuboCop
   module Cop
     module Rails
-      # 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

@@ -22,6 +22,9 @@ 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.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it may change handling time.
+      #
       # @example EnforcedStyle: flexible (default)
       #   # bad
       #   Date.today
@@ -51,24 +54,21 @@ module RuboCop
       #   # bad
       #   date.to_time
       class Date < Base
+        extend AutoCorrector
+
         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
@@ -97,7 +97,9 @@ module RuboCop
 
             message = format(DEPRECATED_MSG, deprecated: method[:deprecated], relevant: method[:relevant])
 
-            add_offense(node.loc.selector, message: message)
+            add_offense(node.loc.selector, message: message) do |corrector|
+              corrector.replace(node.loc.selector, method[:relevant].to_s)
+            end
           end
         end
 
@@ -113,7 +115,9 @@ module RuboCop
 
           message = format(MSG, method_called: method_name, day: day)
 
-          add_offense(node.loc.selector, message: message)
+          add_offense(node.loc.selector, message: message) do |corrector|
+            corrector.replace(node.receiver.loc.name, 'Time.zone')
+          end
         end
 
         def extract_method_chain(node)

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

@@ -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
@@ -60,7 +68,7 @@ module RuboCop
 
         def_node_matcher :delegate?, <<~PATTERN
           (def _method_name _args
-            (send (send nil? _) _ ...))
+            (send {(send nil? _) (self)} _ ...))
         PATTERN
 
         def on_def(node)
@@ -74,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
 
@@ -93,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?
@@ -109,6 +118,8 @@ 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
 

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

@@ -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

@@ -37,7 +37,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Avoid manipulating ActiveModel errors as hash directly.'
-        AUTOCORECTABLE_METHODS = %i[<< clear keys].freeze
+        AUTOCORRECTABLE_METHODS = %i[<< clear keys].freeze
+        INCOMPATIBLE_METHODS = %i[keys values to_h to_xml].freeze
 
         MANIPULATIVE_METHODS = Set[
           *%i[
@@ -55,7 +56,7 @@ module RuboCop
           {
             #root_manipulation?
             #root_assignment?
-            #errors_keys?
+            #errors_deprecated?
             #messages_details_manipulation?
             #messages_details_assignment?
           }
@@ -77,10 +78,10 @@ module RuboCop
             ...)
         PATTERN
 
-        def_node_matcher :errors_keys?, <<~PATTERN
+        def_node_matcher :errors_deprecated?, <<~PATTERN
           (send
             (send #receiver_matcher :errors)
-            :keys)
+            {:keys :values :to_h :to_xml})
         PATTERN
 
         def_node_matcher :messages_details_manipulation?, <<~PATTERN
@@ -106,10 +107,10 @@ module RuboCop
 
         def on_send(node)
           any_manipulation?(node) do
-            next if node.method?(:keys) && target_rails_version <= 6.0
+            next if target_rails_version <= 6.0 && INCOMPATIBLE_METHODS.include?(node.method_name)
 
             add_offense(node) do |corrector|
-              next unless AUTOCORECTABLE_METHODS.include?(node.method_name)
+              next if skip_autocorrect?(node)
 
               autocorrect(corrector, node)
             end
@@ -118,14 +119,16 @@ module RuboCop
 
         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
 
-          if receiver.receiver.send_type? && receiver.receiver.method?(:messages)
-            corrector.remove(receiver.receiver.loc.dot)
-            corrector.remove(receiver.receiver.loc.selector)
-          end
-
           range = offense_range(node, receiver)
           replacement = replacement(node, receiver)
 
@@ -133,11 +136,12 @@ module RuboCop
         end
 
         def offense_range(node, receiver)
-          range_between(receiver.receiver.source_range.end_pos, node.source_range.end_pos)
+          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 '.errors.attribute_names' if node.method?(:keys)
+          return '.attribute_names' if node.method?(:keys)
 
           key = receiver.first_argument.source
 
@@ -156,7 +160,7 @@ module RuboCop
         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

@@ -24,7 +24,7 @@ module RuboCop
         TRANSLATE_METHODS = %i[translate t].freeze
 
         def_node_matcher :translate_with_scope?, <<~PATTERN
-          (send {nil? (const nil? :I18n)} {:translate :t} ${sym_type? str_type?}
+          (send {nil? (const {nil? cbase} :I18n)} {:translate :t} ${sym_type? str_type?}
             (hash <$(pair (sym :scope) ${array_type? sym_type?}) ...>)
           )
         PATTERN
@@ -37,7 +37,7 @@ module RuboCop
 
             add_offense(scope_node) do |corrector|
               # Eat the comma on the left.
-              range = range_with_surrounding_space(range: scope_node.source_range, side: :left)
+              range = range_with_surrounding_space(scope_node.source_range, side: :left)
               range = range_with_surrounding_comma(range, :left)
               corrector.remove(range)
 

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

@@ -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

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

@@ -22,19 +22,23 @@ module RuboCop
       #   User.find_by(name: name, email: email)
       #   User.find_by!(email: email)
       #
-      # @example AllowedMethods: find_by_sql
+      # @example AllowedMethods: ['find_by_sql', 'find_by_token_for'] (default)
       #   # bad
       #   User.find_by_query(users_query)
+      #   User.find_by_token_for(:password_reset, token)
       #
       #   # good
       #   User.find_by_sql(users_sql)
+      #   User.find_by_token_for(:password_reset, token)
       #
-      # @example AllowedReceivers: Gem::Specification
+      # @example AllowedReceivers: ['Gem::Specification', 'page'] (default)
       #   # bad
       #   Specification.find_by_name('backend').gem_dir
+      #   page.find_by_id('a_dom_id').click
       #
       #   # good
       #   Gem::Specification.find_by_name('backend').gem_dir
+      #   page.find_by_id('a_dom_id').click
       class DynamicFindBy < Base
         include ActiveRecordHelper
         extend AutoCorrector
@@ -49,7 +53,7 @@ module RuboCop
           method_name = node.method_name
           static_name = static_method_name(method_name)
           return unless static_name
-          return if node.arguments.any? { |argument| IGNORED_ARGUMENT_TYPES.include?(argument.type) }
+          return unless dynamic_find_by_arguments?(node)
 
           message = format(MSG, static_name: static_name, method: method_name)
           add_offense(node, message: message) do |corrector|
@@ -61,17 +65,12 @@ module RuboCop
         private
 
         def autocorrect(corrector, node)
-          keywords = column_keywords(node.method_name)
-
-          return if keywords.size != node.arguments.size
-
           autocorrect_method_name(corrector, node)
-          autocorrect_argument_keywords(corrector, node, keywords)
+          autocorrect_argument_keywords(corrector, node, column_keywords(node.method_name))
         end
 
         def allowed_invocation?(node)
-          allowed_method?(node) || allowed_receiver?(node) ||
-            whitelisted?(node)
+          allowed_method?(node) || allowed_receiver?(node) || whitelisted?(node)
         end
 
         def allowed_method?(node)
@@ -95,13 +94,12 @@ module RuboCop
         end
 
         def autocorrect_method_name(corrector, node)
-          corrector.replace(node.loc.selector,
-                            static_method_name(node.method_name.to_s))
+          corrector.replace(node.loc.selector, static_method_name(node.method_name.to_s))
         end
 
         def autocorrect_argument_keywords(corrector, node, keywords)
           keywords.each.with_index do |keyword, idx|
-            corrector.insert_before(node.arguments[idx].loc.expression, keyword)
+            corrector.insert_before(node.arguments[idx], keyword)
           end
         end
 
@@ -118,6 +116,20 @@ module RuboCop
 
           match[2] ? 'find_by!' : 'find_by'
         end
+
+        def dynamic_find_by_arguments?(node)
+          dynamic_find_by_arguments_count?(node) && dynamic_find_by_arguments_type?(node)
+        end
+
+        def dynamic_find_by_arguments_count?(node)
+          column_keywords(node.method_name).size == node.arguments.size
+        end
+
+        def dynamic_find_by_arguments_type?(node)
+          node.arguments.none? do |argument|
+            IGNORED_ARGUMENT_TYPES.include?(argument.type)
+          end
+        end
       end
     end
   end

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

@@ -37,6 +37,10 @@ module RuboCop
           )
         PATTERN
 
+        def self.autocorrect_incompatible_with
+          [Style::MethodCallWithArgsParentheses]
+        end
+
         def on_send(node)
           return if node.parent&.block_type?
 
@@ -55,7 +59,7 @@ module RuboCop
         private
 
         def replacement_range(node)
-          stop = node.loc.expression.end
+          stop = node.source_range.end
           start = node.loc.selector.end
 
           if node.parenthesized_call?

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

@@ -42,7 +42,7 @@ module RuboCop
                   "#{source(elem)} => #{index}"
                 end.join(', ')
 
-                corrector.replace(array.loc.expression, "{#{hash}}")
+                corrector.replace(array, "{#{hash}}")
               end
             end
           end

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

@@ -20,8 +20,7 @@ module RuboCop
       class EnumUniqueness < Base
         include Duplication
 
-        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
-              'enum declaration.'
+        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` enum declaration.'
         RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
@@ -41,9 +40,7 @@ module RuboCop
                 next unless duplicates?(items)
 
                 consecutive_duplicates(items).each do |item|
-                  add_offense(item, message: format(
-                    MSG, value: item.source, enum: enum_name(key)
-                  ))
+                  add_offense(item, message: format(MSG, value: item.source, enum: enum_name(key)))
                 end
               end
             end

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

@@ -84,7 +84,7 @@ module RuboCop
         def autocorrect(corrector, node)
           replacement = build_predicate_method(node)
 
-          corrector.replace(node.source_range, replacement)
+          corrector.replace(node, replacement)
         end
 
         def build_predicate_method(node)
@@ -96,8 +96,7 @@ module RuboCop
         end
 
         def rails_env_on_lhs?(node)
-          comparing_str_env_with_rails_env_on_lhs?(node) ||
-            comparing_sym_env_with_rails_env_on_lhs?(node)
+          comparing_str_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_lhs?(node)
         end
 
         def build_predicate_method_for_rails_env_on_lhs(node)