rubocop-rails 2.33.4 → 2.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ddb8c79abf97afc451393bd9a309ac575a99057e1143d4e4632fa84568173e8b
-  data.tar.gz: b6cf48b796104788e4d2302f379328071dc5b5042f3cd6923eb625a3ec19128d
+  metadata.gz: ffddf417706a66433be596f397b807c824a2593bea0a5175907be9d9be318970
+  data.tar.gz: 40672bac8ab7a1961102c3f5306526fa98a360987c7095128313dd5bae7c5641
 SHA512:
-  metadata.gz: 2618f426daf94c51e8fceb989eca50055dae465b334a5ef83d5dc940959a123e1f3a2337246db86defd3f189970a1848a207b5b6b8afcf9917149877bd3fee3e
-  data.tar.gz: 164f84eeab842a88a39131e8c8949584487ac22893604de862ecc28cd984d6df2e5e244ab82e57295dbe9abba0c71830c018412325eccaa3a6ff376f3517ecfc
+  metadata.gz: 16ba2fc1926397b8b5c413c207a9f45e80a30b53e1e73b215e18abf38218e3aea3ecd2090cc4858adfe4a9d32ebb527b83db57acb38cff48510d4eaf18dcdd9c
+  data.tar.gz: 6541216ccafd3cd5287517989ea8a49dcb4b547ca98d0c363f58ac5a11ebbe6452329ea0964357e7f9777a5224d05d271b6bd21ee31f0d0bffcb37dfaa26dbd0

data/config/default.yml

@@ -408,7 +408,7 @@ Rails/DuplicateAssociation:
   VersionChanged: '2.18'
 
 Rails/DuplicateScope:
-  Description: 'Multiple scopes share this same where clause.'
+  Description: 'Multiple scopes share this same expression.'
   Enabled: pending
   Severity: warning
   VersionAdded: '2.14'
@@ -468,6 +468,11 @@ Rails/EnumUniqueness:
   Include:
     - '**/app/models/**/*.rb'
 
+Rails/Env:
+  Description: 'Use Feature Flags or config instead of `Rails.env`.'
+  Enabled: false
+  VersionAdded: '2.34'
+
 Rails/EnvLocal:
   Description: 'Use `Rails.env.local?` instead of `Rails.env.development? || Rails.env.test?`.'
   Enabled: pending
@@ -609,6 +614,14 @@ Rails/HttpStatus:
     - numeric
     - symbolic
 
+Rails/HttpStatusNameConsistency:
+  Description: 'Enforces consistency by using the current HTTP status names.'
+  Enabled: pending
+  Severity: warning
+  VersionAdded: '2.34'
+  Include:
+    - '**/app/controllers/**/*.rb'
+
 Rails/I18nLazyLookup:
   Description: 'Checks for places where I18n "lazy" lookup can be used.'
   StyleGuide: 'https://rails.rubystyle.guide/#lazy-lookup'
@@ -831,6 +844,7 @@ Rails/Presence:
   Description: 'Checks code that can be written more easily using `Object#presence` defined by Active Support.'
   Enabled: true
   VersionAdded: '0.52'
+  VersionChanged: '2.34'
 
 Rails/Present:
   Description: 'Enforces use of `present?`.'
@@ -867,6 +881,14 @@ Rails/ReadWriteAttribute:
   Include:
     - '**/app/models/**/*.rb'
 
+Rails/RedirectBackOrTo:
+  Description: >-
+                  Use `redirect_back_or_to` instead of `redirect_back` with
+                  `fallback_location` option.
+  Enabled: pending
+  Severity: warning
+  VersionAdded: '2.34'
+
 Rails/RedundantActiveRecordAllMethod:
   Description: Detect redundant `all` used as a receiver for Active Record query methods.
   StyleGuide: 'https://rails.rubystyle.guide/#redundant-all'

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

@@ -98,7 +98,9 @@ module RuboCop
         end
 
         def use_redirect_to?(context)
-          context.right_siblings.compact.any? do |sibling|
+          context.right_siblings.any? do |sibling|
+            next unless sibling.is_a?(AST::Node)
+
             # Unwrap `return redirect_to :index`
             sibling = sibling.children.first if sibling.return_type? && sibling.children.one?
             sibling.send_type? && sibling.method?(:redirect_to)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # 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 expression. This
       # often means you copy/pasted a scope, updated the name, and forgot to change the condition.
       #
       # @example
@@ -19,7 +19,7 @@ module RuboCop
       class DuplicateScope < Base
         include ClassSendNodeHelper
 
-        MSG = 'Multiple scopes share this same where clause.'
+        MSG = 'Multiple scopes share this same expression.'
 
         def_node_matcher :scope, <<~PATTERN
           (send nil? :scope _ $...)

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for usage of `Rails.env` which can be replaced with Feature Flags
+      #
+      # @example
+      #
+      #   # bad
+      #   Rails.env.production? || Rails.env.local?
+      #
+      #   # good
+      #   if FeatureFlag.enabled?(:new_feature)
+      #     # new feature code
+      #   end
+      #
+      class Env < Base
+        MSG = 'Use Feature Flags or config instead of `Rails.env`.'
+        RESTRICT_ON_SEND = %i[env].freeze
+        # This allow list is derived from:
+        # (Rails.env.methods - Object.instance_methods).select { |m| m.to_s.end_with?('?') }
+        # and then removing the environment specific methods like development?, test?, production?, local?
+        ALLOWED_LIST = Set.new(
+          %i[
+            unicode_normalized?
+            exclude?
+            empty?
+            acts_like_string?
+            include?
+            is_utf8?
+            casecmp?
+            match?
+            starts_with?
+            ends_with?
+            start_with?
+            end_with?
+            valid_encoding?
+            ascii_only?
+            between?
+          ]
+        ).freeze
+
+        def on_send(node)
+          return unless node.receiver&.const_name == 'Rails'
+
+          parent = node.parent
+          return unless parent&.predicate_method?
+
+          return if ALLOWED_LIST.include?(parent.method_name)
+
+          add_offense(parent)
+        end
+      end
+    end
+  end
+end

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

@@ -3,12 +3,13 @@
 module RuboCop
   module Cop
     module Rails
-      # Checks that Rails.env is compared using `.production?`-like
+      # Checks that `Rails.env` is compared using `.production?`-like
       # methods instead of equality against a string or symbol.
       #
       # @example
       #   # bad
       #   Rails.env == 'production'
+      #   Rails.env.to_sym == :production
       #
       #   # bad, always returns false
       #   Rails.env == :test
@@ -18,26 +19,40 @@ module RuboCop
       class EnvironmentComparison < Base
         extend AutoCorrector
 
-        MSG = 'Favor `%<bang>sRails.env.%<env>s?` over `%<source>s`.'
+        MSG = 'Favor `%<prefer>s` over `%<source>s`.'
 
         SYM_MSG = 'Do not compare `Rails.env` with a symbol, it will always evaluate to `false`.'
 
         RESTRICT_ON_SEND = %i[== !=].freeze
 
-        def_node_matcher :comparing_str_env_with_rails_env_on_lhs?, <<~PATTERN
-          (send
-            (send (const {nil? cbase} :Rails) :env)
-            {:== :!=}
-            $str
-          )
+        def_node_matcher :comparing_env_with_rails_env_on_lhs?, <<~PATTERN
+          {
+            (send
+              (send (const {nil? cbase} :Rails) :env)
+              {:== :!=}
+              $str
+            )
+            (send
+              (send (send (const {nil? cbase} :Rails) :env) :to_sym)
+              {:== :!=}
+              $sym
+            )
+          }
         PATTERN
 
-        def_node_matcher :comparing_str_env_with_rails_env_on_rhs?, <<~PATTERN
-          (send
-            $str
-            {:== :!=}
-            (send (const {nil? cbase} :Rails) :env)
-          )
+        def_node_matcher :comparing_env_with_rails_env_on_rhs?, <<~PATTERN
+          {
+            (send
+              $str
+              {:== :!=}
+              (send (const {nil? cbase} :Rails) :env)
+            )
+            (send
+              $sym
+              {:== :!=}
+              (send (send (const {nil? cbase} :Rails) :env) :to_sym)
+            )
+          }
         PATTERN
 
         def_node_matcher :comparing_sym_env_with_rails_env_on_lhs?, <<~PATTERN
@@ -56,59 +71,52 @@ module RuboCop
           )
         PATTERN
 
-        def_node_matcher :content, <<~PATTERN
-          ({str sym} $_)
-        PATTERN
-
         def on_send(node)
-          if (env_node = comparing_str_env_with_rails_env_on_lhs?(node) ||
-                         comparing_str_env_with_rails_env_on_rhs?(node))
-            env, = *env_node
-            bang = node.method?(:!=) ? '!' : ''
-            message = format(MSG, bang: bang, env: env, source: node.source)
-
-            add_offense(node, message: message) do |corrector|
-              autocorrect(corrector, node)
-            end
+          check_env_comparison_with_rails_env(node)
+          check_sym_env_comparison_with_rails_env(node)
+        end
+
+        private
+
+        def check_env_comparison_with_rails_env(node)
+          return unless comparing_env_with_rails_env_on_lhs?(node) || comparing_env_with_rails_env_on_rhs?(node)
+
+          replacement = build_predicate_method(node)
+          message = format(MSG, prefer: replacement, source: node.source)
+
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement)
           end
+        end
 
+        def check_sym_env_comparison_with_rails_env(node)
           return unless comparing_sym_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_rhs?(node)
 
           add_offense(node, message: SYM_MSG) do |corrector|
-            autocorrect(corrector, node)
+            replacement = build_predicate_method(node)
+            corrector.replace(node, replacement)
           end
         end
 
-        private
+        def build_predicate_method(node)
+          bang = node.method?(:!=) ? '!' : ''
 
-        def autocorrect(corrector, node)
-          replacement = build_predicate_method(node)
+          receiver, argument = extract_receiver_and_argument(node)
+          receiver = receiver.receiver if receiver.method?(:to_sym)
 
-          corrector.replace(node, replacement)
+          "#{bang}#{receiver.source}.#{argument.value}?"
         end
 
-        def build_predicate_method(node)
+        def extract_receiver_and_argument(node)
           if rails_env_on_lhs?(node)
-            build_predicate_method_for_rails_env_on_lhs(node)
+            [node.receiver, node.first_argument]
           else
-            build_predicate_method_for_rails_env_on_rhs(node)
+            [node.first_argument, node.receiver]
           end
         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)
-        end
-
-        def build_predicate_method_for_rails_env_on_lhs(node)
-          bang = node.method?(:!=) ? '!' : ''
-
-          "#{bang}#{node.receiver.source}.#{content(node.first_argument)}?"
-        end
-
-        def build_predicate_method_for_rails_env_on_rhs(node)
-          bang = node.method?(:!=) ? '!' : ''
-
-          "#{bang}#{node.first_argument.source}.#{content(node.receiver)}?"
+          comparing_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_lhs?(node)
         end
       end
     end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Rails
-      # Enforces that `exit` calls are not used within a rails app.
+      # Enforces that `exit` and `abort` calls are not used within a rails app.
       # Valid options are instead to raise an error, break, return, or some
       # other form of stopping execution of current request.
       #
@@ -26,12 +26,15 @@ module RuboCop
       class Exit < Base
         include ConfigurableEnforcedStyle
 
-        MSG = 'Do not use `exit` in Rails applications.'
-        RESTRICT_ON_SEND = %i[exit exit!].freeze
+        MSG = 'Do not use `%<current>s` in Rails applications.'
+        RESTRICT_ON_SEND = %i[exit exit! abort].freeze
         EXPLICIT_RECEIVERS = %i[Kernel Process].freeze
 
         def on_send(node)
-          add_offense(node.loc.selector) if offending_node?(node)
+          return unless offending_node?(node)
+
+          message = format(MSG, current: node.method_name)
+          add_offense(node.loc.selector, message: message)
         end
 
         private

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

@@ -8,6 +8,9 @@ module RuboCop
       # 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.
@@ -56,14 +59,16 @@ module RuboCop
 
         # 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 |varible_name, find_by|
+          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 #{varible_name} if defined?(#{varible_name})
+                  return #{variable_name} if defined?(#{variable_name})
 
-                  #{varible_name} = #{find_by.source}
+                  #{variable_name} = #{find_by.source}
                 RUBY
               )
 
@@ -74,17 +79,18 @@ module RuboCop
 
         def on_send(node)
           assignment_node = node.parent
-          find_by_or_assignment_memoization(assignment_node) do |varible_name, find_by|
-            next if assignment_node.each_ancestor(:if).any?
+
+          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?(#{varible_name})
-                    #{varible_name}
+                  if defined?(#{variable_name})
+                    #{variable_name}
                   else
-                    #{varible_name} = #{find_by.source}
+                    #{variable_name} = #{find_by.source}
                   end
                 RUBY
               )
@@ -94,6 +100,18 @@ module RuboCop
 
         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)
 

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/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/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/presence.rb

@@ -37,6 +37,22 @@ 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
       class Presence < Base
         include RangeHelp
         extend AutoCorrector
@@ -46,29 +62,29 @@ module RuboCop
         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 +98,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 +129,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)
+          node.method?('[]') || node.arithmetic_operation?
+        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 +174,12 @@ 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
       end
     end
   end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Checks for uses of `redirect_back(fallback_location: ...)` and
+      # suggests using `redirect_back_or_to(...)` instead.
+      #
+      # `redirect_back(fallback_location: ...)` was soft deprecated in Rails 7.0 and
+      # `redirect_back_or_to` was introduced as a replacement.
+      #
+      # @example
+      #   # bad
+      #   redirect_back(fallback_location: root_path)
+      #
+      #   # good
+      #   redirect_back_or_to(root_path)
+      #
+      #   # bad
+      #   redirect_back(fallback_location: root_path, allow_other_host: false)
+      #
+      #   # good
+      #   redirect_back_or_to(root_path, allow_other_host: false)
+      #
+      class RedirectBackOrTo < Base
+        extend AutoCorrector
+        extend TargetRailsVersion
+
+        minimum_target_rails_version 7.0
+
+        MSG = 'Use `redirect_back_or_to` instead of `redirect_back` with `:fallback_location` keyword argument.'
+        RESTRICT_ON_SEND = %i[redirect_back].freeze
+
+        def_node_matcher :redirect_back_with_fallback_location, <<~PATTERN
+          (send nil? :redirect_back
+            (hash <$(pair (sym :fallback_location) $_) ...>)
+          )
+        PATTERN
+
+        def on_send(node)
+          redirect_back_with_fallback_location(node) do |fallback_pair, fallback_value|
+            add_offense(node.loc.selector) do |corrector|
+              correct_redirect_back(corrector, node, fallback_pair, fallback_value)
+            end
+          end
+        end
+
+        private
+
+        def correct_redirect_back(corrector, node, fallback_pair, fallback_value)
+          corrector.replace(node.loc.selector, 'redirect_back_or_to')
+
+          hash_arg = node.first_argument
+
+          if hash_arg.pairs.one?
+            corrector.replace(hash_arg, fallback_value.source)
+          else
+            remove_fallback_location_pair(corrector, hash_arg, fallback_pair)
+            first_pair = hash_arg.pairs.find { |pair| pair != fallback_pair }
+            corrector.insert_before(first_pair, "#{fallback_value.source}, ")
+          end
+        end
+
+        def remove_fallback_location_pair(corrector, hash_node, fallback_pair)
+          pairs = hash_node.pairs
+          index = pairs.index(fallback_pair)
+
+          if pairs.one?
+            corrector.remove(fallback_pair)
+          elsif index.zero?
+            remove_first_pair(corrector, fallback_pair, pairs[1])
+          else
+            remove_non_first_pair(corrector, fallback_pair, pairs[index - 1])
+          end
+        end
+
+        def remove_first_pair(corrector, fallback_pair, next_pair)
+          range = fallback_pair.source_range.join(next_pair.source_range.begin)
+          corrector.remove(range)
+        end
+
+        def remove_non_first_pair(corrector, fallback_pair, prev_pair)
+          range = prev_pair.source_range.end.join(fallback_pair.source_range.end)
+          corrector.remove(range)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails_cops.rb

@@ -50,6 +50,7 @@ require_relative 'rails/eager_evaluation_log_message'
 require_relative 'rails/enum_hash'
 require_relative 'rails/enum_syntax'
 require_relative 'rails/enum_uniqueness'
+require_relative 'rails/env'
 require_relative 'rails/env_local'
 require_relative 'rails/environment_comparison'
 require_relative 'rails/environment_variable_access'
@@ -66,6 +67,7 @@ require_relative 'rails/has_many_or_has_one_dependent'
 require_relative 'rails/helper_instance_variable'
 require_relative 'rails/http_positional_arguments'
 require_relative 'rails/http_status'
+require_relative 'rails/http_status_name_consistency'
 require_relative 'rails/i18n_lazy_lookup'
 require_relative 'rails/i18n_locale_assignment'
 require_relative 'rails/i18n_locale_texts'
@@ -102,6 +104,7 @@ require_relative 'rails/redundant_foreign_key'
 require_relative 'rails/redundant_presence_validation_on_belongs_to'
 require_relative 'rails/redundant_receiver_in_with_options'
 require_relative 'rails/redundant_travel_back'
+require_relative 'rails/redirect_back_or_to'
 require_relative 'rails/reflection_class_name'
 require_relative 'rails/refute_methods'
 require_relative 'rails/relative_date_constant'

data/lib/rubocop/rails/version.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Rails
     # This module holds the RuboCop Rails version information.
     module Version
-      STRING = '2.33.4'
+      STRING = '2.34.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-rails
 version: !ruby/object:Gem::Version
-  version: 2.33.4
+  version: 2.34.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -156,6 +156,7 @@ files:
 - lib/rubocop/cop/rails/enum_hash.rb
 - lib/rubocop/cop/rails/enum_syntax.rb
 - lib/rubocop/cop/rails/enum_uniqueness.rb
+- lib/rubocop/cop/rails/env.rb
 - lib/rubocop/cop/rails/env_local.rb
 - lib/rubocop/cop/rails/environment_comparison.rb
 - lib/rubocop/cop/rails/environment_variable_access.rb
@@ -172,6 +173,7 @@ files:
 - lib/rubocop/cop/rails/helper_instance_variable.rb
 - lib/rubocop/cop/rails/http_positional_arguments.rb
 - lib/rubocop/cop/rails/http_status.rb
+- lib/rubocop/cop/rails/http_status_name_consistency.rb
 - lib/rubocop/cop/rails/i18n_lazy_lookup.rb
 - lib/rubocop/cop/rails/i18n_locale_assignment.rb
 - lib/rubocop/cop/rails/i18n_locale_texts.rb
@@ -202,6 +204,7 @@ files:
 - lib/rubocop/cop/rails/present.rb
 - lib/rubocop/cop/rails/rake_environment.rb
 - lib/rubocop/cop/rails/read_write_attribute.rb
+- lib/rubocop/cop/rails/redirect_back_or_to.rb
 - lib/rubocop/cop/rails/redundant_active_record_all_method.rb
 - lib/rubocop/cop/rails/redundant_allow_nil.rb
 - lib/rubocop/cop/rails/redundant_foreign_key.rb
@@ -266,7 +269,7 @@ metadata:
   homepage_uri: https://docs.rubocop.org/rubocop-rails/
   changelog_uri: https://github.com/rubocop/rubocop-rails/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop-rails/
-  documentation_uri: https://docs.rubocop.org/rubocop-rails/2.33/
+  documentation_uri: https://docs.rubocop.org/rubocop-rails/2.34/
   bug_tracker_uri: https://github.com/rubocop/rubocop-rails/issues
   rubygems_mfa_required: 'true'
   default_lint_roller_plugin: RuboCop::Rails::Plugin
@@ -284,7 +287,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.0.dev
 specification_version: 4
 summary: Automatic Rails code style checking tool.
 test_files: []