rubocop-rails 2.32.0 → 2.34.2

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Avoid memoizing `find_by` results with `||=`.
+      #
+      # It is common to see code that attempts to memoize `find_by` result by `||=`,
+      # but `find_by` may return `nil`, in which case it is not memoized as intended.
+      #
+      # NOTE: Respecting the object shapes introduced in Ruby 3.2, instance variables used
+      # for memoization that are initialized at object creation are ignored.
+      #
+      # @safety
+      #   This cop is unsafe because detected `find_by` may not be Active Record's method,
+      #   or the code may have a different purpose than memoization.
+      #
+      # @example
+      #   # bad - exclusively doing memoization
+      #   def current_user
+      #     @current_user ||= User.find_by(id: session[:user_id])
+      #   end
+      #
+      #   # good
+      #   def current_user
+      #     return @current_user if defined?(@current_user)
+      #
+      #     @current_user = User.find_by(id: session[:user_id])
+      #   end
+      #
+      #   # bad - method contains other code
+      #   def current_user
+      #     @current_user ||= User.find_by(id: session[:user_id])
+      #     @current_user.do_something
+      #   end
+      #
+      #   # good
+      #   def current_user
+      #     if defined?(@current_user)
+      #       @current_user
+      #     else
+      #       @current_user = User.find_by(id: session[:user_id])
+      #     end
+      #     @current_user.do_something
+      #   end
+      class FindByOrAssignmentMemoization < Base
+        extend AutoCorrector
+
+        MSG = 'Avoid memoizing `find_by` results with `||=`.'
+
+        RESTRICT_ON_SEND = %i[find_by].freeze
+
+        def_node_matcher :find_by_or_assignment_memoization, <<~PATTERN
+          (or_asgn
+            (ivasgn $_)
+            $(send _ :find_by ...)
+          )
+        PATTERN
+
+        # When a method body contains only memoization, the correction can be more succinct.
+        def on_def(node)
+          find_by_or_assignment_memoization(node.body) do |variable_name, find_by|
+            next if instance_variable_assigned?(variable_name)
+
+            add_offense(node.body) do |corrector|
+              corrector.replace(
+                node.body,
+                <<~RUBY.rstrip
+                  return #{variable_name} if defined?(#{variable_name})
+
+                  #{variable_name} = #{find_by.source}
+                RUBY
+              )
+
+              correct_to_regular_method_definition(corrector, node) if node.endless?
+            end
+          end
+        end
+
+        def on_send(node)
+          assignment_node = node.parent
+
+          find_by_or_assignment_memoization(assignment_node) do |variable_name, find_by|
+            next if assignment_node.each_ancestor(:if).any? || instance_variable_assigned?(variable_name)
+
+            add_offense(assignment_node) do |corrector|
+              corrector.replace(
+                assignment_node,
+                <<~RUBY.rstrip
+                  if defined?(#{variable_name})
+                    #{variable_name}
+                  else
+                    #{variable_name} = #{find_by.source}
+                  end
+                RUBY
+              )
+            end
+          end
+        end
+
+        private
+
+        def instance_variable_assigned?(instance_variable_name)
+          initialize_methods.any? do |def_node|
+            def_node.each_descendant(:ivasgn).any? do |asgn_node|
+              asgn_node.name == instance_variable_name
+            end
+          end
+        end
+
+        def initialize_methods
+          @initialize_methods ||= processed_source.ast.each_descendant(:def).select { |node| node.method?(:initialize) }
+        end
+
+        def correct_to_regular_method_definition(corrector, node)
+          range = node.loc.assignment.join(node.body.source_range.begin)
+
+          corrector.replace(range, "\n")
+          corrector.insert_after(node, "\nend")
+        end
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module RuboCop
       # variable, consider moving the behavior elsewhere, for
       # example to a model, decorator or presenter.
       #
-      # Provided that a class inherits `ActionView::Helpers::FormBuilder`,
+      # Provided that an instance variable belongs to a class,
       # an offense will not be registered.
       #
       # @example
@@ -28,38 +28,37 @@ module RuboCop
       #   end
       #
       #   # good
-      #   class MyFormBuilder < ActionView::Helpers::FormBuilder
-      #     @template.do_something
+      #   module ButtonHelper
+      #     class Welcome
+      #       def initialize(text:)
+      #         @text = text
+      #       end
+      #     end
+      #
+      #     def welcome(**)
+      #       render Welcome.new(**)
+      #     end
       #   end
+      #
       class HelperInstanceVariable < Base
         MSG = 'Do not use instance variables in helpers.'
 
-        def_node_matcher :form_builder_class?, <<~PATTERN
-          (const
-            (const
-               (const {nil? cbase} :ActionView) :Helpers) :FormBuilder)
-        PATTERN
-
         def on_ivar(node)
-          return if inherit_form_builder?(node)
+          return if instance_variable_belongs_to_class?(node)
 
           add_offense(node)
         end
 
         def on_ivasgn(node)
-          return if node.parent.or_asgn_type? || inherit_form_builder?(node)
+          return if node.parent.or_asgn_type? || instance_variable_belongs_to_class?(node)
 
           add_offense(node.loc.name)
         end
 
         private
 
-        def inherit_form_builder?(node)
-          node.each_ancestor(:class) do |class_node|
-            return true if form_builder_class?(class_node.parent_class)
-          end
-
-          false
+        def instance_variable_belongs_to_class?(node)
+          node.each_ancestor(:class).any?
         end
       end
     end

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

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Enforces consistency by using the current HTTP status names.
+      #
+      # @example
+      #   # bad
+      #   render json: { error: "Invalid data" }, status: :unprocessable_entity
+      #   head :payload_too_large
+      #
+      #   # good
+      #   render json: { error: "Invalid data" }, status: :unprocessable_content
+      #   head :content_too_large
+      #
+      class HttpStatusNameConsistency < Base
+        extend AutoCorrector
+
+        requires_gem 'rack', '>= 3.1.0'
+
+        RESTRICT_ON_SEND = %i[render redirect_to head assert_response assert_redirected_to].freeze
+
+        PREFERRED_STATUSES = {
+          unprocessable_entity: :unprocessable_content,
+          payload_too_large: :content_too_large
+        }.freeze
+
+        MSG = 'Prefer `:%<preferred>s` over `:%<current>s`.'
+
+        def_node_matcher :status_method_call, <<~PATTERN
+          {
+            (send nil? {:render :redirect_to} _ $hash)
+            (send nil? {:render :redirect_to} $hash)
+            (send nil? {:head :assert_response} $_ ...)
+            (send nil? :assert_redirected_to _ $hash ...)
+            (send nil? :assert_redirected_to $hash ...)
+          }
+        PATTERN
+
+        def_node_matcher :status_hash_value, <<~PATTERN
+          (hash <(pair (sym :status) $_) ...>)
+        PATTERN
+
+        def on_send(node)
+          status_method_call(node) do |status_node|
+            if status_node.hash_type?
+              # Handle hash arguments like { status: :unprocessable_entity }
+              status_hash_value(status_node) do |status_value|
+                check_status_name_consistency(status_value)
+              end
+            else
+              # Handle positional arguments like head :unprocessable_entity
+              check_status_name_consistency(status_node)
+            end
+          end
+        end
+
+        private
+
+        def check_status_name_consistency(node)
+          if node.sym_type? && PREFERRED_STATUSES.key?(node.value)
+            current_status = node.value
+            preferred_status = PREFERRED_STATUSES[current_status]
+
+            message = format(MSG, current: current_status, preferred: preferred_status)
+
+            add_offense(node, message: message) do |corrector|
+              corrector.replace(node, ":#{preferred_status}")
+            end
+          else
+            node.children.each do |child|
+              check_status_name_consistency(child) if child.is_a?(Parser::AST::Node)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,11 @@ module RuboCop
       # an enumerable into a hash where the keys are the original elements.
       # Rails provides the `index_with` method for this purpose.
       #
+      # @safety
+      #   This cop is marked as unsafe autocorrection, because `nil.to_h` returns {}
+      #   but `nil.with_index` throws `NoMethodError`. Therefore, autocorrection is not
+      #   compatible if the receiver is nil.
+      #
       # @example
       #   # bad
       #   [1, 2, 3].each_with_object({}) { |el, h| h[el] = foo(el) }

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

@@ -178,6 +178,7 @@ module RuboCop
           (pair (sym :inverse_of) nil)
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_send(node)
           recv, arguments = association_recv_arguments(node)
           return unless arguments
@@ -192,9 +193,11 @@ module RuboCop
           return unless scope?(arguments) || options_requiring_inverse_of?(options)
 
           return if options_contain_inverse_of?(options)
+          return if dynamic_options?(options) && options.none? { |opt| inverse_of_nil_option?(opt) }
 
           add_offense(node.loc.selector, message: message(options))
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def scope?(arguments)
           !ignore_scopes? && arguments.any?(&:block_type?)
@@ -216,6 +219,10 @@ module RuboCop
           end
         end
 
+        def dynamic_options?(options)
+          options.any? { |option| option&.kwsplat_type? }
+        end
+
         def options_contain_inverse_of?(options)
           options.any? { |opt| inverse_of_option?(opt) }
         end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Prefer symbol arguments over strings in `order` method.
+      #
+      # @safety
+      #   Cop is unsafe because the receiver might not be an Active Record query.
+      #
+      # @example
+      #   # bad
+      #   User.order('name')
+      #   User.order('name DESC')
+      #
+      #   # good
+      #   User.order(:name)
+      #   User.order(name: :desc)
+      #
+      class OrderArguments < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer `%<prefer>s` instead.'
+
+        RESTRICT_ON_SEND = %i[order].freeze
+
+        def_node_matcher :string_order, <<~PATTERN
+          (call _ :order (str $_value)+)
+        PATTERN
+
+        ORDER_EXPRESSION_REGEX = /\A(\w+) ?(asc|desc)?\z/i.freeze
+
+        def on_send(node)
+          return unless (current_expressions = string_order(node))
+          return unless (preferred_expressions = replacement(current_expressions))
+
+          offense_range = find_offense_range(node)
+          add_offense(offense_range, message: format(MSG, prefer: preferred_expressions)) do |corrector|
+            corrector.replace(offense_range, preferred_expressions)
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def find_offense_range(node)
+          node.first_argument.source_range.join(node.last_argument.source_range)
+        end
+
+        def replacement(order_expressions)
+          order_arguments = order_expressions.flat_map { |expr| expr.split(',') }
+          order_arguments.map! { |arg| extract_column_and_direction(arg.strip) }
+
+          return if order_arguments.any?(&:nil?)
+          return if order_arguments.any? { |column_name, _| positional_column?(column_name) }
+
+          convert_to_preferred_arguments(order_arguments).join(', ')
+        end
+
+        def convert_to_preferred_arguments(order_expressions)
+          use_hash = false
+          order_expressions.map do |column, direction|
+            if direction == :asc && !use_hash
+              ":#{column}"
+            else
+              use_hash = true
+              "#{column}: :#{direction}"
+            end
+          end
+        end
+
+        def positional_column?(column_name)
+          column_name.match?(/\A\d+\z/)
+        end
+
+        def extract_column_and_direction(order_expression)
+          return unless (column, direction = ORDER_EXPRESSION_REGEX.match(order_expression)&.captures)
+
+          [column.downcase, direction&.downcase&.to_sym || :asc]
+        end
+      end
+    end
+  end
+end

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

@@ -38,9 +38,11 @@ module RuboCop
             ...)
         PATTERN
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
           return if node.parent&.call_type? || node.block_node
           return if !output?(node) && !io_output?(node)
+          return if node.arguments.any? { |arg| arg.type?(:hash, :block_pass) }
 
           range = offense_range(node)
 
@@ -48,6 +50,7 @@ module RuboCop
             corrector.replace(range, 'Rails.logger.debug')
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 

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

@@ -84,7 +84,9 @@ module RuboCop
         private
 
         def non_interpolated_string?(node)
-          node.receiver&.str_type? && !node.receiver.dstr_type?
+          return false unless (receiver = node.receiver)
+
+          receiver.str_type? || (receiver.dstr_type? && receiver.children.all?(&:str_type?))
         end
 
         def looks_like_rails_html_safe?(node)

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

@@ -27,6 +27,9 @@ module RuboCop
       # end
       # ----
       #
+      # If a method call has no receiver, like `do_something { users.map { |user| user[:foo] }`,
+      # it is not considered part of an iteration and will be detected.
+      #
       # @safety
       #   This cop is unsafe because model can use column aliases.
       #
@@ -59,9 +62,9 @@ module RuboCop
           (any_block (call _ {:map :collect}) $_argument (send lvar :[] $_key))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
-          return if node.each_ancestor(:any_block).any?
+          return if node.each_ancestor(:any_block).first&.receiver
 
           pluck_candidate?(node) do |argument, key|
             next if key.regexp_type? || !use_one_block_argument?(argument)
@@ -79,7 +82,7 @@ module RuboCop
             register_offense(node, key)
           end
         end
-        # rubocop:enable Metrics/AbcSize
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_numblock on_block
         alias on_itblock on_block
 

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

@@ -37,38 +37,65 @@ module RuboCop
       #
       #   # good
       #   a.presence || b
+      #
+      # @example
+      #   # bad
+      #   a.present? ? a.foo : nil
+      #
+      #   # bad
+      #   !a.present? ? nil : a.foo
+      #
+      #   # bad
+      #   a.blank? ? nil : a.foo
+      #
+      #   # bad
+      #   !a.blank? ? a.foo : nil
+      #
+      #   # good
+      #   a.presence&.foo
+      #
+      #   # good
+      #   a.present? ? a[1] : nil
+      #
+      #   # good
+      #   a[:key] = value if a.present?
+      #
+      #   # good
+      #   a.present? ? a > 1 : nil
+      #   a <= 0 if a.present?
       class Presence < Base
         include RangeHelp
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<current>s`.'
+        INDEX_ACCESS_METHODS = %i[[] []=].freeze
 
         def_node_matcher :redundant_receiver_and_other, <<~PATTERN
           {
             (if
-              (send $_recv :present?)
-              _recv
+              {(send $_recv :blank?) (send (send $_recv :present?) :!)}
               $!begin
+              _recv
             )
             (if
-              (send $_recv :blank?)
-              $!begin
+              {(send $_recv :present?) (send (send $_recv :blank?) :!)}
               _recv
+              $!begin
             )
           }
         PATTERN
 
-        def_node_matcher :redundant_negative_receiver_and_other, <<~PATTERN
+        def_node_matcher :redundant_receiver_and_chain, <<~PATTERN
           {
             (if
-              (send (send $_recv :present?) :!)
-              $!begin
-              _recv
+              {(send $_recv :blank?) (send (send $_recv :present?) :!)}
+              {nil? nil_type?}
+              $(send _recv ...)
             )
             (if
-              (send (send $_recv :blank?) :!)
-              _recv
-              $!begin
+              {(send $_recv :present?) (send (send $_recv :blank?) :!)}
+              $(send _recv ...)
+              {nil? nil_type?}
             )
           }
         PATTERN
@@ -82,18 +109,26 @@ module RuboCop
             register_offense(node, receiver, other)
           end
 
-          redundant_negative_receiver_and_other(node) do |receiver, other|
-            return if ignore_other_node?(other) || receiver.nil?
+          redundant_receiver_and_chain(node) do |receiver, chain|
+            return if ignore_chain_node?(chain) || receiver.nil?
 
-            register_offense(node, receiver, other)
+            register_chain_offense(node, receiver, chain)
           end
         end
 
         private
 
         def register_offense(node, receiver, other)
-          add_offense(node, message: message(node, receiver, other)) do |corrector|
-            corrector.replace(node, replacement(receiver, other, node.left_sibling))
+          replacement = replacement(receiver, other, node.left_sibling)
+          add_offense(node, message: message(node, replacement)) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+
+        def register_chain_offense(node, receiver, chain)
+          replacement = chain_replacement(receiver, chain, node.left_sibling)
+          add_offense(node, message: message(node, replacement)) do |corrector|
+            corrector.replace(node, replacement)
           end
         end
 
@@ -105,8 +140,12 @@ module RuboCop
           node&.type?(:if, :rescue, :while)
         end
 
-        def message(node, receiver, other)
-          prefer = replacement(receiver, other, node.left_sibling).gsub(/^\s*|\n/, '')
+        def ignore_chain_node?(node)
+          index_access_method?(node) || node.assignment? || node.arithmetic_operation? || node.comparison_method?
+        end
+
+        def message(node, replacement)
+          prefer  = replacement.gsub(/^\s*|\n/, '')
           current = current(node).gsub(/^\s*|\n/, '')
           format(MSG, prefer: prefer, current: current)
         end
@@ -146,6 +185,16 @@ module RuboCop
         def method_range(node)
           range_between(node.source_range.begin_pos, node.first_argument.source_range.begin_pos - 1)
         end
+
+        def chain_replacement(receiver, chain, left_sibling)
+          replaced = "#{receiver.source}.presence&.#{chain.method_name}"
+          replaced += "(#{chain.arguments.map(&:source).join(', ')})" if chain.arguments?
+          left_sibling ? "(#{replaced})" : replaced
+        end
+
+        def index_access_method?(node)
+          INDEX_ACCESS_METHODS.include?(node.method_name)
+        end
       end
     end
   end

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

@@ -66,7 +66,7 @@ module RuboCop
           return false unless enclosing_method
 
           shadowing_method_name = first_arg.value.to_s
-          shadowing_method_name << '=' if node.method?(:write_attribute)
+          shadowing_method_name += '=' if node.method?(:write_attribute)
           enclosing_method.method?(shadowing_method_name)
         end