rubocop-rails 2.20.2 → 2.24.1

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

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # TODO: In the future, please support only RuboCop 1.52+ and use `RuboCop::Cop::AllowedReceivers`:
+      #       https://github.com/rubocop/rubocop/blob/v1.52.0/lib/rubocop/cop/mixin/allowed_receivers.rb
+      #       At that time, this duplicated module implementation can be removed.
+      module AllowedReceivers
+        def allowed_receiver?(receiver)
+          receiver_name = receiver_name(receiver)
+
+          allowed_receivers.include?(receiver_name)
+        end
+
+        def receiver_name(receiver)
+          return receiver_name(receiver.receiver) if receiver.receiver && !receiver.receiver.const_type?
+
+          if receiver.send_type?
+            if receiver.receiver
+              "#{receiver_name(receiver.receiver)}.#{receiver.method_name}"
+            else
+              receiver.method_name.to_s
+            end
+          else
+            receiver.source
+          end
+        end
+
+        def allowed_receivers
+          cop_config.fetch('AllowedReceivers', [])
+        end
+      end
+
+      # Detect redundant `all` used as a receiver for Active Record query methods.
+      #
+      # For the methods `delete_all` and `destroy_all`, this cop will only check cases where the receiver is a model.
+      # It will ignore cases where the receiver is an association (e.g., `user.articles.all.delete_all`).
+      # This is because omitting `all` from an association changes the methods
+      # from `ActiveRecord::Relation` to `ActiveRecord::Associations::CollectionProxy`,
+      # which can affect their behavior.
+      #
+      # @safety
+      #   This cop is unsafe for autocorrection if the receiver for `all` is not an Active Record object.
+      #
+      # @example
+      #   # bad
+      #   User.all.find(id)
+      #   User.all.order(:created_at)
+      #   users.all.where(id: ids)
+      #   user.articles.all.order(:created_at)
+      #
+      #   # good
+      #   User.find(id)
+      #   User.order(:created_at)
+      #   users.where(id: ids)
+      #   user.articles.order(:created_at)
+      #
+      # @example AllowedReceivers: ['ActionMailer::Preview', 'ActiveSupport::TimeZone'] (default)
+      #   # good
+      #   ActionMailer::Preview.all.first
+      #   ActiveSupport::TimeZone.all.first
+      class RedundantActiveRecordAllMethod < Base
+        include ActiveRecordHelper
+        include AllowedReceivers
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant `all` detected.'
+
+        RESTRICT_ON_SEND = [:all].freeze
+
+        # Defined methods in `ActiveRecord::Querying::QUERYING_METHODS` on activerecord 7.1.0.
+        QUERYING_METHODS = %i[
+          and
+          annotate
+          any?
+          async_average
+          async_count
+          async_ids
+          async_maximum
+          async_minimum
+          async_pick
+          async_pluck
+          async_sum
+          average
+          calculate
+          count
+          create_or_find_by
+          create_or_find_by!
+          create_with
+          delete_all
+          delete_by
+          destroy_all
+          destroy_by
+          distinct
+          eager_load
+          except
+          excluding
+          exists?
+          extending
+          extract_associated
+          fifth
+          fifth!
+          find
+          find_by
+          find_by!
+          find_each
+          find_in_batches
+          find_or_create_by
+          find_or_create_by!
+          find_or_initialize_by
+          find_sole_by
+          first
+          first!
+          first_or_create
+          first_or_create!
+          first_or_initialize
+          forty_two
+          forty_two!
+          fourth
+          fourth!
+          from
+          group
+          having
+          ids
+          in_batches
+          in_order_of
+          includes
+          invert_where
+          joins
+          last
+          last!
+          left_joins
+          left_outer_joins
+          limit
+          lock
+          many?
+          maximum
+          merge
+          minimum
+          none
+          none?
+          offset
+          one?
+          only
+          optimizer_hints
+          or
+          order
+          pick
+          pluck
+          preload
+          readonly
+          references
+          regroup
+          reorder
+          reselect
+          rewhere
+          second
+          second!
+          second_to_last
+          second_to_last!
+          select
+          sole
+          strict_loading
+          sum
+          take
+          take!
+          third
+          third!
+          third_to_last
+          third_to_last!
+          touch_all
+          unscope
+          update_all
+          where
+          with
+          without
+        ].to_set.freeze
+
+        POSSIBLE_ENUMERABLE_BLOCK_METHODS = %i[any? count find none? one? select sum].freeze
+        SENSITIVE_METHODS_ON_ASSOCIATION = %i[delete_all destroy_all].freeze
+
+        def_node_matcher :followed_by_query_method?, <<~PATTERN
+          (send (send _ :all) QUERYING_METHODS ...)
+        PATTERN
+
+        def on_send(node)
+          return unless followed_by_query_method?(node.parent)
+          return if possible_enumerable_block_method?(node) || sensitive_association_method?(node)
+          return if node.receiver ? allowed_receiver?(node.receiver) : !inherit_active_record_base?(node)
+
+          range_of_all_method = offense_range(node)
+          add_offense(range_of_all_method) do |collector|
+            collector.remove(range_of_all_method)
+            collector.remove(node.parent.loc.dot)
+          end
+        end
+
+        private
+
+        def possible_enumerable_block_method?(node)
+          parent = node.parent
+          return false unless POSSIBLE_ENUMERABLE_BLOCK_METHODS.include?(parent.method_name)
+
+          parent.parent&.block_type? || parent.parent&.numblock_type? || parent.first_argument&.block_pass_type?
+        end
+
+        def sensitive_association_method?(node)
+          !node.receiver&.const_type? && SENSITIVE_METHODS_ON_ASSOCIATION.include?(node.parent.method_name)
+        end
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -53,6 +53,12 @@ module RuboCop
         #   @example source that matches - by a foreign key
         #     validates :user_id, presence: true
         #
+        #   @example source that DOES NOT match - if condition
+        #     validates :user_id, presence: true, if: condition
+        #
+        #   @example source that DOES NOT match - unless condition
+        #     validates :user_id, presence: true, unless: condition
+        #
         #   @example source that DOES NOT match - strict validation
         #     validates :user_id, presence: true, strict: true
         #
@@ -65,6 +71,7 @@ module RuboCop
             $[
               (hash <$(pair (sym :presence) true) ...>)         # presence: true
               !(hash <$(pair (sym :strict) {true const}) ...>)  # strict: true
+              !(hash <$(pair (sym {:if :unless}) _) ...>)       # if: some_condition or unless: some_condition
             ]
           )
         PATTERN

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

@@ -100,7 +100,7 @@ module RuboCop
                  else
                    return false if node.arguments.empty?
 
-                   arg = node.arguments.first
+                   arg = node.first_argument
                    ->(n) { same_value?(arg, n.receiver) }
                  end
 

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

@@ -3,25 +3,30 @@
 module RuboCop
   module Cop
     module Rails
-      # Prefer `response.parsed_body` to `JSON.parse(response.body)`.
+      # Prefer `response.parsed_body` to custom parsing logic for `response.body`.
       #
       # @safety
-      #   This cop is unsafe because Content-Type may not be `application/json`. For example, the proprietary
-      #   Content-Type provided by corporate entities such as `application/vnd.github+json` is not supported at
-      #   `response.parsed_body` by default, so you still have to use `JSON.parse(response.body)` there.
+      #   This cop is unsafe because Content-Type may not be `application/json` or `text/html`.
+      #   For example, the proprietary Content-Type provided by corporate entities such as
+      #   `application/vnd.github+json` is not supported at `response.parsed_body` by default,
+      #   so you still have to use `JSON.parse(response.body)` there.
       #
       # @example
       #   # bad
       #   JSON.parse(response.body)
       #
+      #   # bad
+      #   Nokogiri::HTML.parse(response.body)
+      #
+      #   # bad
+      #   Nokogiri::HTML5.parse(response.body)
+      #
       #   # good
       #   response.parsed_body
       class ResponseParsedBody < Base
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Prefer `response.parsed_body` to `JSON.parse(response.body)`.'
-
         RESTRICT_ON_SEND = %i[parse].freeze
 
         minimum_target_rails_version 5.0
@@ -38,12 +43,27 @@ module RuboCop
           )
         PATTERN
 
+        # @!method nokogiri_html_parse_response_body(node)
+        def_node_matcher :nokogiri_html_parse_response_body, <<~PATTERN
+          (send
+            (const
+              (const {nil? cbase} :Nokogiri)
+              ${:HTML :HTML5}
+            )
+            :parse
+            (send
+              (send nil? :response)
+              :body
+            )
+          )
+        PATTERN
+
         def on_send(node)
-          return unless json_parse_response_body?(node)
+          check_json_parse_response_body(node)
 
-          add_offense(node) do |corrector|
-            autocorrect(corrector, node)
-          end
+          return unless target_rails_version >= 7.1
+
+          check_nokogiri_html_parse_response_body(node)
         end
 
         private
@@ -51,6 +71,28 @@ module RuboCop
         def autocorrect(corrector, node)
           corrector.replace(node, 'response.parsed_body')
         end
+
+        def check_json_parse_response_body(node)
+          return unless json_parse_response_body?(node)
+
+          add_offense(
+            node,
+            message: 'Prefer `response.parsed_body` to `JSON.parse(response.body)`.'
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
+
+        def check_nokogiri_html_parse_response_body(node)
+          return unless (const = nokogiri_html_parse_response_body(node))
+
+          add_offense(
+            node,
+            message: "Prefer `response.parsed_body` to `Nokogiri::#{const}.parse(response.body)`."
+          ) do |corrector|
+            autocorrect(corrector, node)
+          end
+        end
       end
     end
   end

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

@@ -17,7 +17,7 @@ module RuboCop
       #   # good
       #   def change
       #     change_table :users do |t|
-      #       t.remove :name, :string
+      #       t.remove :name, type: :string
       #     end
       #   end
       #
@@ -290,10 +290,10 @@ module RuboCop
           when :change
             false
           when :remove
-            target_rails_version >= 6.1 && all_hash_key?(node.arguments.last, :type)
+            target_rails_version >= 6.1 && all_hash_key?(node.last_argument, :type)
           when :change_default, :change_column_default, :change_table_comment,
                :change_column_comment
-            all_hash_key?(node.arguments.last, :from, :to)
+            all_hash_key?(node.last_argument, :from, :to)
           else
             true
           end
@@ -307,7 +307,7 @@ module RuboCop
 
         def within_reversible_or_up_only_block?(node)
           node.each_ancestor(:block).any? do |ancestor|
-            (ancestor.block_type? && ancestor.send_node.method?(:reversible)) || ancestor.send_node.method?(:up_only)
+            (ancestor.block_type? && ancestor.method?(:reversible)) || ancestor.method?(:up_only)
           end
         end
 

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

@@ -12,7 +12,7 @@ module RuboCop
       # `Style/FileRead`, `Style/FileWrite` and `Rails/RootJoinChain`.
       #
       # @safety
-      #   This cop is unsafe for autocorrection because `Dir`'s `children`, `each_child`, `entries`, and `glob`
+      #   This cop is unsafe for autocorrection because ``Dir``'s `children`, `each_child`, `entries`, and `glob`
       #   methods return string element, but these methods of `Pathname` return `Pathname` element.
       #
       # @example
@@ -32,13 +32,28 @@ module RuboCop
       #   Rails.root.join('db', 'schema.rb').write(content)
       #   Rails.root.join('db', 'schema.rb').binwrite(content)
       #
-      class RootPathnameMethods < Base
+      class RootPathnameMethods < Base # rubocop:disable Metrics/ClassLength
         extend AutoCorrector
         include RangeHelp
 
         MSG = '`%<rails_root>s` is a `Pathname` so you can just append `#%<method>s`.'
 
-        DIR_METHODS = %i[children delete each_child empty? entries exist? glob mkdir open rmdir unlink].to_set.freeze
+        DIR_GLOB_METHODS = %i[glob].to_set.freeze
+
+        DIR_NON_GLOB_METHODS = %i[
+          children
+          delete
+          each_child
+          empty?
+          entries
+          exist?
+          mkdir
+          open
+          rmdir
+          unlink
+        ].to_set.freeze
+
+        DIR_METHODS = (DIR_GLOB_METHODS + DIR_NON_GLOB_METHODS).freeze
 
         FILE_METHODS = %i[
           atime
@@ -134,7 +149,8 @@ module RuboCop
 
         RESTRICT_ON_SEND = (DIR_METHODS + FILE_METHODS + FILE_TEST_METHODS + FILE_UTILS_METHODS).to_set.freeze
 
-        def_node_matcher :pathname_method, <<~PATTERN
+        # @!method pathname_method_for_ruby_2_5_or_higher(node)
+        def_node_matcher :pathname_method_for_ruby_2_5_or_higher, <<~PATTERN
           {
             (send (const {nil? cbase} :Dir) $DIR_METHODS $_ $...)
             (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
@@ -143,6 +159,16 @@ module RuboCop
           }
         PATTERN
 
+        # @!method pathname_method_for_ruby_2_4_or_lower(node)
+        def_node_matcher :pathname_method_for_ruby_2_4_or_lower, <<~PATTERN
+          {
+            (send (const {nil? cbase} :Dir) $DIR_NON_GLOB_METHODS $_ $...)
+            (send (const {nil? cbase} {:IO :File}) $FILE_METHODS $_ $...)
+            (send (const {nil? cbase} :FileTest) $FILE_TEST_METHODS $_ $...)
+            (send (const {nil? cbase} :FileUtils) $FILE_UTILS_METHODS $_ $...)
+          }
+        PATTERN
+
         def_node_matcher :dir_glob?, <<~PATTERN
           (send
             (const {cbase nil?} :Dir) :glob ...)
@@ -183,6 +209,14 @@ module RuboCop
           yield(method, path, args, rails_root)
         end
 
+        def pathname_method(node)
+          if target_ruby_version >= 2.5
+            pathname_method_for_ruby_2_5_or_higher(node)
+          else
+            pathname_method_for_ruby_2_4_or_lower(node)
+          end
+        end
+
         def build_path_glob_replacement(path, method)
           receiver = range_between(path.source_range.begin_pos, path.children.first.loc.selector.end_pos).source
 

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

@@ -188,7 +188,7 @@ module RuboCop
         end
 
         def persisted_referenced?(assignment)
-          return unless assignment.referenced?
+          return false unless assignment.referenced?
 
           assignment.variable.references.any? do |reference|
             call_to_persisted?(reference.node.parent)
@@ -196,6 +196,8 @@ module RuboCop
         end
 
         def call_to_persisted?(node)
+          node = node.parent.condition if node.parenthesized_call? && node.parent.if_type?
+
           node.send_type? && node.method?(:persisted?)
         end
 
@@ -235,10 +237,10 @@ module RuboCop
 
         def in_condition_or_compound_boolean?(node)
           node = node.block_node || node
-          parent = node.parent
+          parent = node.each_ancestor.find { |ancestor| !ancestor.begin_type? }
           return false unless parent
 
-          operator_or_single_negative?(parent) || (conditional?(parent) && node == parent.condition)
+          operator_or_single_negative?(parent) || (conditional?(parent) && node == deparenthesize(parent.condition))
         end
 
         def operator_or_single_negative?(node)
@@ -249,6 +251,11 @@ module RuboCop
           parent.if_type? || parent.case_type?
         end
 
+        def deparenthesize(node)
+          node = node.children.last while node.begin_type?
+          node
+        end
+
         def checked_immediately?(node)
           node.parent && call_to_persisted?(node.parent)
         end
@@ -298,7 +305,7 @@ module RuboCop
 
           node = assignable_node(node)
           method, sibling_index = find_method_with_sibling_index(node.parent)
-          return unless method && (method.def_type? || method.block_type?)
+          return false unless method && (method.def_type? || method.block_type?)
 
           method.children.size == node.sibling_index + sibling_index
         end
@@ -331,10 +338,10 @@ module RuboCop
 
         # Check argument signature as no arguments or one hash
         def expected_signature?(node)
-          !node.arguments? ||
-            (node.arguments.one? &&
-              node.method_name != :destroy &&
-              (node.first_argument.hash_type? || !node.first_argument.literal?))
+          return true unless node.arguments?
+          return false if !node.arguments.one? || node.method?(:destroy)
+
+          node.first_argument.hash_type? || !node.first_argument.literal?
         end
       end
     end

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

@@ -74,17 +74,25 @@ module RuboCop
         def on_send(node)
           if add_column_without_comment?(node)
             add_offense(node, message: COLUMN_MSG)
-          elsif create_table?(node)
-            if create_table_without_comment?(node)
-              add_offense(node, message: TABLE_MSG)
-            elsif create_table_column_call_without_comment?(node)
-              add_offense(node.parent.body, message: COLUMN_MSG)
-            end
+          elsif create_table_without_comment?(node)
+            add_offense(node, message: TABLE_MSG)
+          elsif create_table_with_block?(node.parent)
+            check_column_within_create_table_block(node.parent.body)
           end
         end
 
         private
 
+        def check_column_within_create_table_block(node)
+          if node.begin_type?
+            node.child_nodes.each do |child_node|
+              add_offense(child_node, message: COLUMN_MSG) if t_column_without_comment?(child_node)
+            end
+          elsif t_column_without_comment?(node)
+            add_offense(node, message: COLUMN_MSG)
+          end
+        end
+
         def add_column_without_comment?(node)
           add_column?(node) && !add_column_with_comment?(node)
         end
@@ -93,10 +101,8 @@ module RuboCop
           create_table?(node) && !create_table_with_comment?(node)
         end
 
-        def create_table_column_call_without_comment?(node)
-          create_table_with_block?(node.parent) &&
-            t_column?(node.parent.body) &&
-            !t_column_with_comment?(node.parent.body)
+        def t_column_without_comment?(node)
+          t_column?(node) && !t_column_with_comment?(node)
         end
       end
     end

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

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for uses of `select(:column_name)` with `map(&:column_name)`.
+      # These can be replaced with `pluck(:column_name)`.
+      #
+      # There also should be some performance improvement since it skips instantiating the model class for matches.
+      #
+      # @safety
+      #   This cop is unsafe because the model might override the attribute getter.
+      #   Additionally, the model's `after_initialize` hooks are skipped when using `pluck`.
+      #
+      # @example
+      #   # bad
+      #   Model.select(:column_name).map(&:column_name)
+      #
+      #   # good
+      #   Model.pluck(:column_name)
+      #
+      class SelectMap < Base
+        extend AutoCorrector
+
+        MSG = 'Use `%<preferred_method>s` instead of `select` with `%<map_method>s`.'
+
+        RESTRICT_ON_SEND = %i[map collect].freeze
+
+        def on_send(node)
+          return unless node.first_argument
+
+          column_name = node.first_argument.source.delete_prefix('&:')
+          return unless (select_node = find_select_node(node, column_name))
+
+          offense_range = select_node.loc.selector.begin.join(node.source_range.end)
+          preferred_method = "pluck(:#{column_name})"
+          message = format(MSG, preferred_method: preferred_method, map_method: node.method_name)
+
+          add_offense(offense_range, message: message) do |corrector|
+            autocorrect(corrector, select_node, node, preferred_method)
+          end
+        end
+
+        private
+
+        def find_select_node(node, column_name)
+          node.descendants.detect do |select_candidate|
+            next if !select_candidate.send_type? || !select_candidate.method?(:select)
+
+            match_column_name?(select_candidate, column_name)
+          end
+        end
+
+        # rubocop:disable Metrics/AbcSize
+        def autocorrect(corrector, select_node, node, preferred_method)
+          corrector.remove(select_node.loc.dot || node.loc.dot)
+          corrector.remove(select_node.loc.selector.begin.join(select_node.source_range.end))
+          corrector.replace(node.loc.selector.begin.join(node.source_range.end), preferred_method)
+        end
+        # rubocop:enable Metrics/AbcSize
+
+        def match_column_name?(select_candidate, column_name)
+          return false unless select_candidate.arguments.one?
+          return false unless (first_argument = select_candidate.first_argument)
+
+          argument = case select_candidate.first_argument.type
+                     when :sym
+                       first_argument.source.delete_prefix(':')
+                     when :str
+                       first_argument.value if first_argument.respond_to?(:value)
+                     end
+
+          argument == column_name
+        end
+      end
+    end
+  end
+end

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

@@ -21,6 +21,7 @@ module RuboCop
       #   # bad
       #   Time.now
       #   Time.parse('2015-03-02T19:05:37')
+      #   '2015-03-02T19:05:37'.to_time
       #
       #   # good
       #   Time.current
@@ -44,19 +45,17 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Do not use `%<current>s` without zone. Use `%<prefer>s` instead.'
-
         MSG_ACCEPTABLE = 'Do not use `%<current>s` without zone. Use one of %<prefer>s instead.'
-
         MSG_LOCALTIME = 'Do not use `Time.localtime` without offset or zone.'
+        MSG_STRING_TO_TIME = 'Do not use `String#to_time` without zone. Use `Time.zone.parse` instead.'
 
         GOOD_METHODS = %i[zone zone_default find_zone find_zone!].freeze
-
         DANGEROUS_METHODS = %i[now local new parse at].freeze
-
         ACCEPTED_METHODS = %i[in_time_zone utc getlocal xmlschema iso8601 jisx0301 rfc3339 httpdate to_i to_f].freeze
-
         TIMEZONE_SPECIFIER = /([A-Za-z]|[+-]\d{2}:?\d{2})\z/.freeze
 
+        RESTRICT_ON_SEND = %i[to_time].freeze
+
         def on_const(node)
           mod, klass = *node
           # we should only check core classes
@@ -66,6 +65,15 @@ module RuboCop
           check_time_node(klass, node.parent) if klass == :Time
         end
 
+        def on_send(node)
+          return if !node.receiver&.str_type? || !node.method?(:to_time)
+
+          add_offense(node.loc.selector, message: MSG_STRING_TO_TIME) do |corrector|
+            corrector.replace(node, "Time.zone.parse(#{node.receiver.source})") unless node.csend_type?
+          end
+        end
+        alias on_csend on_send
+
         private
 
         def autocorrect(corrector, node)