rubocop-rails 2.30.2 → 2.34.3

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.respond_to?(:predicate_method?) && parent.predicate_method?
+
+          return if ALLOWED_LIST.include?(parent.method_name)
+
+          add_offense(parent)
+        end
+      end
+    end
+  end
+end

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

@@ -24,45 +24,69 @@ module RuboCop
 
         minimum_target_rails_version 7.1
 
-        # @!method rails_env_local_or?(node)
-        def_node_matcher :rails_env_local_or?, <<~PATTERN
-          (or
-            (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
-            (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
-          )
+        # @!method rails_env_local?(node)
+        def_node_matcher :rails_env_local?, <<~PATTERN
+          (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
         PATTERN
 
-        # @!method rails_env_local_and?(node)
-        def_node_matcher :rails_env_local_and?, <<~PATTERN
-          (and
-            (send
-              (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
-              :!)
-            (send
-              (send (send (const {cbase nil? } :Rails) :env) $%LOCAL_ENVIRONMENTS)
-              :!)
-          )
+        # @!method not_rails_env_local?(node)
+        def_node_matcher :not_rails_env_local?, <<~PATTERN
+          (send #rails_env_local? :!)
         PATTERN
 
         def on_or(node)
-          rails_env_local_or?(node) do |*environments|
-            next unless environments.to_set == LOCAL_ENVIRONMENTS
+          lhs, rhs = *node.children
+          return unless rails_env_local?(rhs)
 
-            add_offense(node) do |corrector|
-              corrector.replace(node, 'Rails.env.local?')
-            end
+          nodes = [rhs]
+
+          if rails_env_local?(lhs)
+            nodes << lhs
+          elsif lhs.or_type? && rails_env_local?(lhs.rhs)
+            nodes << lhs.rhs
+          end
+
+          return unless environments(nodes).to_set == LOCAL_ENVIRONMENTS
+
+          range = offense_range(nodes)
+          add_offense(range) do |corrector|
+            corrector.replace(range, 'Rails.env.local?')
           end
         end
 
         def on_and(node)
-          rails_env_local_and?(node) do |*environments|
-            next unless environments.to_set == LOCAL_ENVIRONMENTS
+          lhs, rhs = *node.children
+          return unless not_rails_env_local?(rhs)
+
+          nodes = [rhs]
+
+          if not_rails_env_local?(lhs)
+            nodes << lhs
+          elsif lhs.operator_keyword? && not_rails_env_local?(lhs.rhs)
+            nodes << lhs.rhs
+          end
 
-            add_offense(node, message: MSG_NEGATED) do |corrector|
-              corrector.replace(node, '!Rails.env.local?')
-            end
+          return unless environments(nodes).to_set == LOCAL_ENVIRONMENTS
+
+          range = offense_range(nodes)
+          add_offense(range, message: MSG_NEGATED) do |corrector|
+            corrector.replace(range, '!Rails.env.local?')
           end
         end
+
+        private
+
+        def environments(nodes)
+          if nodes[0].method?(:!)
+            nodes.map { |node| node.receiver.method_name }
+          else
+            nodes.map(&:method_name)
+          end
+        end
+
+        def offense_range(nodes)
+          nodes[1].source_range.begin.join(nodes[0].source_range.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/file_path.rb

@@ -190,7 +190,7 @@ module RuboCop
           else
             replace_with_rails_root_join(corrector, rails_root_node, argument_source)
           end
-          node.children[rails_root_index + 1..].each { |child| corrector.remove(child) }
+          node.children[(rails_root_index + 1)..].each { |child| corrector.remove(child) }
         end
 
         def autocorrect_extension_after_rails_root_join_in_dstr(corrector, node, rails_root_index, extension_node)
@@ -281,7 +281,7 @@ module RuboCop
         end
 
         def extract_rails_root_join_argument_source(node, rails_root_index)
-          node.children[rails_root_index + 1..].map(&:source).join.delete_prefix(File::SEPARATOR)
+          node.children[(rails_root_index + 1)..].map(&:source).join.delete_prefix(File::SEPARATOR)
         end
 
         def extension_node?(node)

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

@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def where_method?(receiver)
-          return false unless receiver
+          return false if !receiver || receiver.any_block_type?
 
           receiver.respond_to?(:method?) && receiver.method?(:where)
         end

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_by.rb

@@ -37,6 +37,9 @@ module RuboCop
             (numblock
               (call _ :to_h) $1
               (array $_ (lvar :_1)))
+            (itblock
+              (call _ :to_h) $:it
+              (array $_ (lvar :it)))
           }
         PATTERN
 
@@ -50,6 +53,9 @@ module RuboCop
               (numblock
                 (call _ {:map :collect}) $1
                 (array $_ (lvar :_1)))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array $_ (lvar :it)))
             }
             :to_h)
         PATTERN
@@ -66,6 +72,9 @@ module RuboCop
               (numblock
                 (call _ {:map :collect}) $1
                 (array $_ (lvar :_1)))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array $_ (lvar :it)))
             }
           )
         PATTERN