rubocop-rails 2.30.2 → 2.33.0

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

@@ -0,0 +1,65 @@
+# 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.
+      #
+      # @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
+      #   def current_user
+      #     @current_user ||= User.find_by(id: session[:user_id])
+      #   end
+      #
+      #   # good
+      #   def current_user
+      #     if instance_variable_defined?(:@current_user)
+      #       @current_user
+      #     else
+      #       @current_user = User.find_by(id: session[:user_id])
+      #     end
+      #   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
+
+        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?
+
+            add_offense(assignment_node) do |corrector|
+              corrector.replace(
+                assignment_node,
+                <<~RUBY.rstrip
+                  if instance_variable_defined?(:#{varible_name})
+                    #{varible_name}
+                  else
+                    #{varible_name} = #{find_by.source}
+                  end
+                RUBY
+              )
+            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

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) }
@@ -40,6 +45,9 @@ module RuboCop
             (numblock
               (call _ :to_h) $1
               (array (lvar :_1) $_))
+            (itblock
+              (call _ :to_h) $:it
+              (array (lvar :it) $_))
           }
         PATTERN
 
@@ -53,6 +61,9 @@ module RuboCop
               (numblock
                 (call _ {:map :collect}) $1
                 (array (lvar :_1) $_))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array (lvar :it) $_))
             }
             :to_h)
         PATTERN
@@ -69,6 +80,9 @@ module RuboCop
               (numblock
                 (call _ {:map :collect}) $1
                 (array (lvar :_1) $_))
+              (itblock
+                (call _ {:map :collect}) $:it
+                (array (lvar :it) $_))
             }
           )
         PATTERN

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

@@ -0,0 +1,79 @@
+# 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?)
+
+          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 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

@@ -23,7 +23,6 @@ module RuboCop
 
         MSG = "Do not write to stdout. Use Rails's logger if you want to log."
         RESTRICT_ON_SEND = %i[ap p pp pretty_print print puts binwrite syswrite write write_nonblock].freeze
-        ALLOWED_TYPES = %i[send csend block numblock].freeze
 
         def_node_matcher :output?, <<~PATTERN
           (send nil? {:ap :p :pp :pretty_print :print :puts} ...)
@@ -39,9 +38,11 @@ module RuboCop
             ...)
         PATTERN
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def on_send(node)
-          return if ALLOWED_TYPES.include?(node.parent&.type)
+          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)
 
@@ -49,6 +50,7 @@ module RuboCop
             corrector.replace(range, 'Rails.logger.debug')
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         private
 

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,8 +62,9 @@ module RuboCop
           (any_block (call _ {:map :collect}) $_argument (send lvar :[] $_key))
         PATTERN
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_block(node)
-          return if node.each_ancestor(:block, :numblock).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)
@@ -68,20 +72,25 @@ module RuboCop
             match = if node.block_type?
                       block_argument = argument.children.first.source
                       use_block_argument_in_key?(block_argument, key)
-                    else # numblock
-                      argument == 1 && use_block_argument_in_key?('_1', key)
+                    elsif node.numblock_type?
+                      use_block_argument_in_key?('_1', key)
+                    else # itblock
+                      use_block_argument_in_key?('it', key)
                     end
             next unless match
 
             register_offense(node, key)
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def use_one_block_argument?(argument)
-          return true if argument == 1 # Checks for numbered argument `_1`.
+          # Checks for numbered argument `_1` or `it block parameter.
+          return true if [1, :it].include?(argument)
 
           argument.respond_to?(:one?) && argument.one?
         end

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

@@ -74,7 +74,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
+              !(hash <$(pair (sym {:if}) _) ...>)               # if: some_condition or unless: some_condition
             ]
           )
         PATTERN
@@ -211,12 +211,12 @@ module RuboCop
 
         def non_optional_belongs_to(node, keys)
           keys.select do |key|
-            belongs_to = belongs_to_for(node, key)
+            belongs_to = belongs_to_for?(node, key)
             belongs_to && !optional?(belongs_to)
           end
         end
 
-        def belongs_to_for(model_class_node, key)
+        def belongs_to_for?(model_class_node, key)
           if key.to_s.end_with?('_id')
             normalized_key = key.to_s.delete_suffix('_id').to_sym
             belongs_to?(model_class_node, key: normalized_key, fk: key)

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

@@ -71,7 +71,7 @@ module RuboCop
         def on_block(node)
           return unless node.method?(:with_options)
           return unless (body = node.body)
-          return unless all_block_nodes_in(body).count.zero?
+          return unless all_block_nodes_in(body).none?
 
           send_nodes = all_send_nodes_in(body)
           return unless redundant_receiver?(send_nodes, node)
@@ -85,18 +85,22 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
         def autocorrect(corrector, send_node, node)
           corrector.remove(send_node.receiver)
           corrector.remove(send_node.loc.dot)
-          corrector.remove(block_argument_range(send_node)) unless node.numblock_type?
+          corrector.remove(block_argument_range(send_node)) if node.block_type?
         end
 
+        # rubocop:disable Metrics/AbcSize
         def redundant_receiver?(send_nodes, node)
           proc = if node.numblock_type?
                    ->(n) { n.receiver.lvar_type? && n.receiver.source == '_1' }
+                 elsif node.itblock_type?
+                   ->(n) { n.receiver.lvar_type? && n.receiver.source == 'it' }
                  else
                    return false if node.arguments.empty?
 
@@ -106,6 +110,7 @@ module RuboCop
 
           send_nodes.all?(&proc)
         end
+        # rubocop:enable Metrics/AbcSize
 
         def block_argument_range(node)
           block_node = node.each_ancestor(:block).first

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

@@ -40,7 +40,7 @@ module RuboCop
 
         def on_send(node)
           association_with_reflection(node) do |reflection_class_name|
-            return if reflection_class_name.value.send_type? && reflection_class_name.value.receiver.nil?
+            return if reflection_class_name.value.send_type? && !reflection_class_name.value.receiver&.const_type?
             return if reflection_class_name.value.lvar_type? && str_assigned?(reflection_class_name)
 
             add_offense(reflection_class_name) do |corrector|
@@ -76,7 +76,7 @@ module RuboCop
         def autocorrect(corrector, class_config)
           class_value = class_config.value
           replacement = const_or_string(class_value)
-          return unless replacement.present?
+          return unless replacement
 
           corrector.replace(class_value, replacement.source.inspect)
         end

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

@@ -90,7 +90,7 @@ module RuboCop
         end
 
         def nested_relative_date(node, &callback)
-          return if node.nil? || node.block_type?
+          return if node.nil? || node.any_block_type?
 
           node.each_child_node do |child|
             nested_relative_date(child, &callback)

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

@@ -205,6 +205,7 @@ module RuboCop
         end
 
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -218,7 +219,7 @@ module RuboCop
           return unless (last_argument = node.last_argument)
 
           drop_table_call(node) do
-            unless node.parent.block_type? || last_argument.block_pass_type?
+            unless node.parent.any_block_type? || last_argument.block_pass_type?
               add_offense(node, message: format(MSG, action: 'drop_table(without block)'))
             end
           end

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

@@ -156,7 +156,7 @@ module RuboCop
           return unless persist_method?(node)
           return if return_value_assigned?(node)
           return if implicit_return?(node)
-          return if check_used_in_condition_or_compound_boolean(node)
+          return if check_used_in_condition_or_compound_boolean?(node)
           return if argument?(node)
           return if explicit_return?(node)
           return if checked_immediately?(node)
@@ -182,7 +182,7 @@ module RuboCop
         def right_assignment_node(assignment)
           node = assignment.node.child_nodes.first
 
-          return node unless node&.block_type?
+          return node unless node&.any_block_type?
 
           node.send_node
         end
@@ -227,7 +227,7 @@ module RuboCop
           array
         end
 
-        def check_used_in_condition_or_compound_boolean(node)
+        def check_used_in_condition_or_compound_boolean?(node)
           return false unless in_condition_or_compound_boolean?(node)
 
           register_offense(node, CREATE_CONDITIONAL_MSG) unless MODIFY_PERSIST_METHODS.include?(node.method_name)
@@ -305,7 +305,7 @@ module RuboCop
 
           node = assignable_node(node)
           method, sibling_index = find_method_with_sibling_index(node.parent)
-          return false unless method&.type?(:def, :block)
+          return false unless method&.type?(:def, :any_block)
 
           method.children.size == node.sibling_index + sibling_index
         end

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

@@ -39,7 +39,7 @@ module RuboCop
 
         # @!method comment_present?(node)
         def_node_matcher :comment_present?, <<~PATTERN
-          (hash <(pair {(sym :comment) (str "comment")} (_ [present?])) ...>)
+          (hash <(pair {(sym :comment) (str "comment")} !{nil (str blank?)}) ...>)
         PATTERN
 
         # @!method add_column?(node)

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

@@ -45,7 +45,7 @@ module RuboCop
 
             return if required_options?(options_node)
 
-            def_node = node.each_ancestor(:def, :defs).first
+            def_node = node.each_ancestor(:any_def).first
             table_node = table_node(node)
             return if def_node && (table_node.nil? || change_column_null?(def_node, table_node, column_node))
 

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

@@ -135,7 +135,9 @@ module RuboCop
         end
 
         def attach_timezone_specifier?(date)
-          date.respond_to?(:value) && TIMEZONE_SPECIFIER.match?(date.value.to_s)
+          return false unless date.respond_to?(:value)
+
+          !date.value.to_s.valid_encoding? || TIMEZONE_SPECIFIER.match?(date.value.to_s)
         end
 
         def build_message(klass, method_name, node)

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

@@ -97,9 +97,11 @@ module RuboCop
 
         def in_transaction_block?(node)
           return false unless transaction_method_name?(node.method_name)
-          return false unless (parent = node.parent)
+          return false unless node.parent&.body
 
-          parent.block_type? && parent.body
+          node.right_siblings.none? do |sibling|
+            sibling.respond_to?(:loop_keyword?) && sibling.loop_keyword?
+          end
         end
 
         def statement(statement_node)
@@ -113,7 +115,7 @@ module RuboCop
         end
 
         def nested_block?(statement_node)
-          name = statement_node.ancestors.find(&:block_type?).children.first.method_name
+          name = statement_node.ancestors.find(&:any_block_type?).children.first.method_name
           !transaction_method_name?(name)
         end
 

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

@@ -52,7 +52,7 @@ module RuboCop
         MSG = 'Use `distinct` before `pluck`.'
         RESTRICT_ON_SEND = %i[uniq].freeze
 
-        def_node_matcher :uniq_before_pluck, '[!^block $(send $(send _ :pluck ...) :uniq ...)]'
+        def_node_matcher :uniq_before_pluck, '[!^any_block $(send $(send _ :pluck ...) :uniq ...)]'
 
         def on_send(node)
           uniq_before_pluck(node) do |uniq_node, pluck_node|

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

@@ -63,7 +63,7 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          find_offenses(node) do |args|
+          find_offenses?(node) do |args|
             return unless convertable_args?(args)
 
             range = correction_range(node)
@@ -87,7 +87,7 @@ module RuboCop
           style == :exists
         end
 
-        def find_offenses(node, &block)
+        def find_offenses?(node, &block)
           if exists_style?
             where_exists_call?(node, &block)
           elsif where_style?

data/lib/rubocop/cop/rails_cops.rb

@@ -58,6 +58,7 @@ require_relative 'rails/expanded_date_range'
 require_relative 'rails/file_path'
 require_relative 'rails/find_by'
 require_relative 'rails/find_by_id'
+require_relative 'rails/find_by_or_assignment_memoization'
 require_relative 'rails/find_each'
 require_relative 'rails/freeze_time'
 require_relative 'rails/has_and_belongs_to_many'
@@ -82,6 +83,7 @@ require_relative 'rails/migration_class_name'
 require_relative 'rails/multiple_route_paths'
 require_relative 'rails/negate_include'
 require_relative 'rails/not_null_column'
+require_relative 'rails/order_arguments'
 require_relative 'rails/order_by_id'
 require_relative 'rails/output'
 require_relative 'rails/output_safety'

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.30.2'
+      STRING = '2.33.0'
 
       def self.document_version
         STRING.match('\d+\.\d+').to_s