rubocop-rails 2.15.2 → 2.17.3

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

@@ -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.loc.expression, side: :left), :left)
         end
       end
     end

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

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

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

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

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

@@ -29,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/blank.rb

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

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

@@ -111,25 +111,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 +174,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
@@ -237,8 +224,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

@@ -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.loc.expression.end_pos
+                    else
+                      node.loc.expression.end_pos
+                    end
 
           range_between(node.loc.selector.begin_pos, end_pos)
         end

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

@@ -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,7 +81,7 @@ 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)

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

@@ -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/delegate.rb

@@ -93,15 +93,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?

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
 

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,8 +70,8 @@ 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
 

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,8 +94,7 @@ 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)
@@ -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?
 

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

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

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

@@ -34,15 +34,15 @@ module RuboCop
         RESTRICT_ON_SEND = %i[join].freeze
 
         def_node_matcher :file_join_nodes?, <<~PATTERN
-          (send (const nil? :File) :join ...)
+          (send (const {nil? cbase} :File) :join ...)
         PATTERN
 
         def_node_search :rails_root_nodes?, <<~PATTERN
-          (send (const nil? :Rails) :root)
+          (send (const {nil? cbase} :Rails) :root)
         PATTERN
 
         def_node_matcher :rails_root_join_nodes?, <<~PATTERN
-          (send (send (const nil? :Rails) :root) :join ...)
+          (send #rails_root_nodes? :join ...)
         PATTERN
 
         def on_dstr(node)
@@ -50,8 +50,7 @@ module RuboCop
           return unless node.children.last.str_type?
 
           last_child_source = node.children.last.source
-          return unless last_child_source.start_with?('.') ||
-                        last_child_source.include?(File::SEPARATOR)
+          return unless last_child_source.start_with?('.') || last_child_source.include?(File::SEPARATOR)
           return if last_child_source.start_with?(':')
 
           register_offense(node)
@@ -97,8 +96,7 @@ module RuboCop
 
         def register_offense(node)
           line_range = node.loc.column...node.loc.last_column
-          source_range = source_range(processed_source.buffer, node.first_line,
-                                      line_range)
+          source_range = source_range(processed_source.buffer, node.first_line, line_range)
           add_offense(source_range)
         end
 

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

@@ -13,11 +13,17 @@ module RuboCop
       #   # good
       #   User.all.find_each
       #
-      # @example IgnoredMethods: ['order']
+      # @example AllowedMethods: ['order']
+      #   # good
+      #   User.order(:foo).each
+      #
+      # @example AllowedPattern: ['order']
       #   # good
       #   User.order(:foo).each
       class FindEach < Base
         include ActiveRecordHelper
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use `find_each` instead of `each`.'
@@ -47,7 +53,7 @@ module RuboCop
 
           method_chain = node.each_node(:send).map(&:method_name)
 
-          (cop_config['IgnoredMethods'].map(&:to_sym) & method_chain).any?
+          method_chain.any? { |method_name| allowed_method?(method_name) || matches_allowed_pattern?(method_name) }
         end
 
         def active_model_error_where?(node)

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies usages of `travel_to` with an argument of the current time and
+      # change them to use `freeze_time` instead.
+      #
+      # @safety
+      #   This cop’s autocorrection is unsafe because `freeze_time` just delegates to
+      #   `travel_to` with a default `Time.now`, it is not strictly equivalent to `Time.now`
+      #   if the argument of `travel_to` is the current time considering time zone.
+      #
+      # @example
+      #   # bad
+      #   travel_to(Time.now)
+      #   travel_to(Time.new)
+      #   travel_to(DateTime.now)
+      #   travel_to(Time.current)
+      #   travel_to(Time.zone.now)
+      #   travel_to(Time.now.in_time_zone)
+      #   travel_to(Time.current.to_time)
+      #
+      #   # good
+      #   freeze_time
+      #
+      class FreezeTime < Base
+        extend AutoCorrector
+
+        MSG = 'Use `freeze_time` instead of `travel_to`.'
+        NOW_METHODS = %i[now new current].freeze
+        CONVERT_METHODS = %i[to_time in_time_zone].freeze
+        RESTRICT_ON_SEND = %i[travel_to].freeze
+
+        # @!method time_now?(node)
+        def_node_matcher :time_now?, <<~PATTERN
+          (const {nil? cbase} {:Time :DateTime})
+        PATTERN
+
+        # @!method zoned_time_now?(node)
+        def_node_matcher :zoned_time_now?, <<~PATTERN
+          (send (const {nil? cbase} :Time) :zone)
+        PATTERN
+
+        def on_send(node)
+          child_node, method_name, time_argument = *node.first_argument&.children
+          return if time_argument || !child_node
+          return unless current_time?(child_node, method_name) || current_time_with_convert?(child_node, method_name)
+
+          add_offense(node) do |corrector|
+            last_argument = node.last_argument
+            freeze_time_method = last_argument.block_pass_type? ? "freeze_time(#{last_argument.source})" : 'freeze_time'
+            corrector.replace(node, freeze_time_method)
+          end
+        end
+
+        private
+
+        def current_time?(node, method_name)
+          return false unless NOW_METHODS.include?(method_name)
+
+          node.send_type? ? zoned_time_now?(node) : time_now?(node)
+        end
+
+        def current_time_with_convert?(node, method_name)
+          return false unless CONVERT_METHODS.include?(method_name)
+
+          child_node, child_method_name, time_argument = *node.children
+          return if time_argument
+
+          current_time?(child_node, child_method_name)
+        end
+      end
+    end
+  end
+end