rubocop-rails 2.19.1 → 2.21.2

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

@@ -35,6 +35,8 @@ module RuboCop
       #   Rails.root.join('app', 'models', 'goober').to_s
       #
       class FilePath < Base
+        extend AutoCorrector
+
         include ConfigurableEnforcedStyle
         include RangeHelp
 
@@ -56,13 +58,10 @@ module RuboCop
 
         def on_dstr(node)
           return unless rails_root_nodes?(node)
-          return unless node.children.last.str_type?
-
-          last_child_source = node.children.last.source
-          return unless last_child_source.start_with?('.') || last_child_source.include?(File::SEPARATOR)
-          return if last_child_source.start_with?(':')
+          return if dstr_separated_by_colon?(node)
 
-          register_offense(node, require_to_s: true)
+          check_for_slash_after_rails_root_in_dstr(node)
+          check_for_extension_after_rails_root_join_in_dstr(node)
         end
 
         def on_send(node)
@@ -73,11 +72,33 @@ module RuboCop
 
         private
 
+        def check_for_slash_after_rails_root_in_dstr(node)
+          rails_root_index = find_rails_root_index(node)
+          slash_node = node.children[rails_root_index + 1]
+          return unless slash_node&.str_type? && slash_node.source.start_with?(File::SEPARATOR)
+
+          register_offense(node, require_to_s: false) do |corrector|
+            autocorrect_slash_after_rails_root_in_dstr(corrector, node, rails_root_index)
+          end
+        end
+
+        def check_for_extension_after_rails_root_join_in_dstr(node)
+          rails_root_index = find_rails_root_index(node)
+          extension_node = node.children[rails_root_index + 1]
+          return unless extension_node?(extension_node)
+
+          register_offense(node, require_to_s: false) do |corrector|
+            autocorrect_extension_after_rails_root_join_in_dstr(corrector, node, rails_root_index, extension_node)
+          end
+        end
+
         def check_for_file_join_with_rails_root(node)
           return unless file_join_nodes?(node)
           return unless node.arguments.any? { |e| rails_root_nodes?(e) }
 
-          register_offense(node, require_to_s: true)
+          register_offense(node, require_to_s: true) do |corrector|
+            autocorrect_file_join(corrector, node)
+          end
         end
 
         def check_for_rails_root_join_with_string_arguments(node)
@@ -87,7 +108,9 @@ module RuboCop
           return unless node.arguments.size > 1
           return unless node.arguments.all?(&:str_type?)
 
-          register_offense(node, require_to_s: false)
+          register_offense(node, require_to_s: false) do |corrector|
+            autocorrect_rails_root_join_with_string_arguments(corrector, node)
+          end
         end
 
         def check_for_rails_root_join_with_slash_separated_path(node)
@@ -96,21 +119,22 @@ module RuboCop
           return unless rails_root_join_nodes?(node)
           return unless node.arguments.any? { |arg| string_with_slash?(arg) }
 
-          register_offense(node, require_to_s: false)
+          register_offense(node, require_to_s: false) do |corrector|
+            autocorrect_rails_root_join_with_slash_separated_path(corrector, node)
+          end
         end
 
         def string_with_slash?(node)
-          node.str_type? && node.source.include?('/')
+          node.str_type? && node.source.include?(File::SEPARATOR)
         end
 
-        def register_offense(node, require_to_s:)
+        def register_offense(node, require_to_s:, &block)
           line_range = node.loc.column...node.loc.last_column
           source_range = source_range(processed_source.buffer, node.first_line, line_range)
-          require_to_s = false if node.dstr_type?
 
           message = build_message(require_to_s)
 
-          add_offense(source_range, message: message)
+          add_offense(source_range, message: message, &block)
         end
 
         def build_message(require_to_s)
@@ -119,6 +143,98 @@ module RuboCop
 
           format(message_template, to_s: to_s)
         end
+
+        def dstr_separated_by_colon?(node)
+          node.children[1..].any? do |child|
+            child.str_type? && child.source.start_with?(':')
+          end
+        end
+
+        def autocorrect_slash_after_rails_root_in_dstr(corrector, node, rails_root_index)
+          rails_root_node = node.children[rails_root_index].children.first
+          argument_source = extract_rails_root_join_argument_source(node, rails_root_index)
+          if rails_root_node.method?(:join)
+            append_argument(corrector, rails_root_node, argument_source)
+          else
+            replace_with_rails_root_join(corrector, rails_root_node, argument_source)
+          end
+          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)
+          rails_root_node = node.children[rails_root_index].children.first
+          return unless rails_root_node.arguments.last.str_type?
+
+          corrector.insert_before(rails_root_node.arguments.last.location.end, extension_node.source)
+          corrector.remove(extension_node)
+        end
+
+        def autocorrect_file_join(corrector, node)
+          corrector.replace(node.receiver, 'Rails.root')
+          corrector.remove(
+            range_with_surrounding_space(
+              range_with_surrounding_comma(
+                node.arguments.first.source_range,
+                :right
+              ),
+              side: :right
+            )
+          )
+          node.arguments.filter(&:str_type?).each do |argument|
+            corrector.replace(argument, argument.value.delete_prefix('/').inspect)
+          end
+          corrector.insert_after(node, '.to_s')
+        end
+
+        def autocorrect_rails_root_join_with_string_arguments(corrector, node)
+          corrector.replace(node.arguments.first, %("#{node.arguments.map(&:value).join('/')}"))
+          node.arguments[1..].each do |argument|
+            corrector.remove(
+              range_with_surrounding_comma(
+                range_with_surrounding_space(
+                  argument.source_range,
+                  side: :left
+                ),
+                :left
+              )
+            )
+          end
+        end
+
+        def autocorrect_rails_root_join_with_slash_separated_path(corrector, node)
+          node.arguments.each do |argument|
+            next unless string_with_slash?(argument)
+
+            index = argument.source.index(File::SEPARATOR)
+            rest = inner_range_of(argument).adjust(begin_pos: index - 1)
+            corrector.remove(rest)
+            corrector.insert_after(argument, %(, "#{rest.source.delete_prefix(File::SEPARATOR)}"))
+          end
+        end
+
+        def inner_range_of(node)
+          node.location.end.with(begin_pos: node.location.begin.end_pos).adjust(end_pos: -1)
+        end
+
+        def find_rails_root_index(node)
+          node.children.index { |child| rails_root_nodes?(child) }
+        end
+
+        def append_argument(corrector, node, argument_source)
+          corrector.insert_after(node.arguments.last, %(, "#{argument_source}"))
+        end
+
+        def replace_with_rails_root_join(corrector, node, argument_source)
+          corrector.replace(node, %<Rails.root.join("#{argument_source}")>)
+        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)
+        end
+
+        def extension_node?(node)
+          node&.str_type? && node.source.match?(/\A\.[A-Za-z]+/)
+        end
       end
     end
   end

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

@@ -34,7 +34,7 @@ module RuboCop
         RESTRICT_ON_SEND = %i[each].freeze
 
         SCOPE_METHODS = %i[
-          all eager_load includes joins left_joins left_outer_joins not preload
+          all eager_load includes joins left_joins left_outer_joins not or preload
           references unscoped where
         ].freeze
 

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

@@ -69,7 +69,7 @@ module RuboCop
           return false unless CONVERT_METHODS.include?(method_name)
 
           child_node, child_method_name, time_argument = *node.children
-          return if time_argument
+          return false if time_argument
 
           current_time?(child_node, child_method_name)
         end

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

@@ -8,6 +8,7 @@ module RuboCop
       # @example EnforcedStyle: symbolic (default)
       #   # bad
       #   render :foo, status: 200
+      #   render :foo, status: '200'
       #   render json: { foo: 'bar' }, status: 200
       #   render plain: 'foo/bar', status: 304
       #   redirect_to root_url, status: 301
@@ -50,7 +51,7 @@ module RuboCop
         PATTERN
 
         def_node_matcher :status_code, <<~PATTERN
-          (hash <(pair (sym :status) ${int sym}) ...>)
+          (hash <(pair (sym :status) ${int sym str}) ...>)
         PATTERN
 
         def on_send(node)
@@ -108,7 +109,7 @@ module RuboCop
           private
 
           def symbol
-            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number)
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE.key(number.to_i)
           end
 
           def number
@@ -133,7 +134,7 @@ module RuboCop
           end
 
           def offensive?
-            !node.int_type? && !permitted_symbol?
+            !node.int_type? && !permitted_symbol? && number
           end
 
           def message

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

@@ -5,7 +5,13 @@ module RuboCop
     module Rails
       # Checks for places where I18n "lazy" lookup can be used.
       #
-      # @example
+      # This cop has two different enforcement modes. When the EnforcedStyle
+      # is `lazy` (the default), explicit lookups are added as offenses.
+      #
+      # When the EnforcedStyle is `explicit` then lazy lookups are added as
+      # offenses.
+      #
+      # @example EnforcedStyle: lazy (default)
       #   # en.yml
       #   # en:
       #   #   books:
@@ -28,11 +34,29 @@ module RuboCop
       #     end
       #   end
       #
+      # @example EnforcedStyle: explicit
+      #   # bad
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('.success')
+      #     end
+      #   end
+      #
+      #   # good
+      #   class BooksController < ApplicationController
+      #     def create
+      #       # ...
+      #       redirect_to books_url, notice: t('books.create.success')
+      #     end
+      #   end
+      #
       class I18nLazyLookup < Base
+        include ConfigurableEnforcedStyle
         include VisibilityHelp
         extend AutoCorrector
 
-        MSG = 'Use "lazy" lookup for the text used in controllers.'
+        MSG = 'Use %<style>s lookup for the text used in controllers.'
 
         RESTRICT_ON_SEND = %i[translate t].freeze
 
@@ -42,23 +66,45 @@ module RuboCop
 
         def on_send(node)
           translate_call?(node) do |key_node|
-            key = key_node.value
-            return if key.to_s.start_with?('.')
+            case style
+            when :lazy
+              handle_lazy_style(node, key_node)
+            when :explicit
+              handle_explicit_style(node, key_node)
+            end
+          end
+        end
+
+        private
 
-            controller, action = controller_and_action(node)
-            return unless controller && action
+        def handle_lazy_style(node, key_node)
+          key = key_node.value
+          return if key.to_s.start_with?('.')
 
-            scoped_key = get_scoped_key(key_node, controller, action)
-            return unless key == scoped_key
+          controller, action = controller_and_action(node)
+          return unless controller && action
 
-            add_offense(key_node) do |corrector|
-              unscoped_key = key_node.value.to_s.split('.').last
-              corrector.replace(key_node, "'.#{unscoped_key}'")
-            end
+          scoped_key = get_scoped_key(key_node, controller, action)
+          return unless key == scoped_key
+
+          add_offense(key_node) do |corrector|
+            unscoped_key = key_node.value.to_s.split('.').last
+            corrector.replace(key_node, "'.#{unscoped_key}'")
           end
         end
 
-        private
+        def handle_explicit_style(node, key_node)
+          key = key_node.value
+          return unless key.to_s.start_with?('.')
+
+          controller, action = controller_and_action(node)
+          return unless controller && action
+
+          scoped_key = get_scoped_key(key_node, controller, action)
+          add_offense(key_node) do |corrector|
+            corrector.replace(key_node, "'#{scoped_key}'")
+          end
+        end
 
         def controller_and_action(node)
           action_node = node.each_ancestor(:def).first
@@ -90,6 +136,10 @@ module RuboCop
 
           path.delete_suffix('Controller').underscore
         end
+
+        def message(_range)
+          format(MSG, style: style)
+        end
       end
     end
   end

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

@@ -80,7 +80,11 @@ module RuboCop
         PATTERN
 
         def_node_matcher :flash_assignment?, <<~PATTERN
-          (send (send nil? :flash) :[]= _ $str)
+          (send
+            {
+              (send nil? :flash)
+              (send (send nil? :flash) :now)
+            } :[]= _ $str)
         PATTERN
 
         def_node_search :mail_subject, <<~PATTERN

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

@@ -36,6 +36,10 @@ module RuboCop
       #       if: -> { trusted_origin? && action_name != "admin" }
       #   end
       class IgnoredSkipActionFilterOption < Base
+        extend AutoCorrector
+
+        include RangeHelp
+
         MSG = <<~MSG.chomp.freeze
           `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
         MSG
@@ -60,9 +64,13 @@ module RuboCop
           options = options_hash(options)
 
           if if_and_only?(options)
-            add_offense(options[:if], message: format(MSG, prefer: :only, ignore: :if))
+            add_offense(options[:if], message: format(MSG, prefer: :only, ignore: :if)) do |corrector|
+              remove_node_with_left_space_and_comma(corrector, options[:if])
+            end
           elsif if_and_except?(options)
-            add_offense(options[:except], message: format(MSG, prefer: :if, ignore: :except))
+            add_offense(options[:except], message: format(MSG, prefer: :if, ignore: :except)) do |corrector|
+              remove_node_with_left_space_and_comma(corrector, options[:except])
+            end
           end
         end
 
@@ -81,6 +89,18 @@ module RuboCop
         def if_and_except?(options)
           options.key?(:if) && options.key?(:except)
         end
+
+        def remove_node_with_left_space_and_comma(corrector, node)
+          corrector.remove(
+            range_with_surrounding_comma(
+              range_with_surrounding_space(
+                node.source_range,
+                side: :left
+              ),
+              :left
+            )
+          )
+        end
       end
     end
   end

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

@@ -122,24 +122,23 @@ module RuboCop
           parent = node.each_ancestor(:class, :module).first
           return unless parent
 
+          # NOTE: a `:begin` node may not exist if the class/module consists of a single statement
           block = parent.each_child_node(:begin).first
-          return unless block
-
           defined_action_methods = defined_action_methods(block)
 
-          methods = array_values(methods_node).reject do |method|
-            defined_action_methods.include?(method)
-          end
+          unmatched_methods = array_values(methods_node) - defined_action_methods
+          return if unmatched_methods.empty?
 
-          message = message(methods, parent)
-          add_offense(node, message: message) unless methods.empty?
+          message = message(unmatched_methods, parent)
+          add_offense(node, message: message)
         end
 
         private
 
         def defined_action_methods(block)
-          defined_methods = block.each_child_node(:def).map(&:method_name)
+          return [] unless block
 
+          defined_methods = block.each_child_node(:def).map(&:method_name)
           defined_methods + aliased_action_methods(block, defined_methods)
         end
 
@@ -176,14 +175,14 @@ module RuboCop
           when :sym
             [node.value]
           when :array
-            node.values.map do |v|
+            node.values.filter_map do |v|
               case v.type
               when :str
                 v.str_content.to_sym
               when :sym
                 v.value
               end
-            end.compact
+            end
           else
             []
           end

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

@@ -45,7 +45,7 @@ module RuboCop
 
         def check_add_column(node)
           add_not_null_column?(node) do |type, pairs|
-            return if type.value == :virtual || type.value == 'virtual'
+            return if type.respond_to?(:value) && (type.value == :virtual || type.value == 'virtual')
 
             check_pairs(pairs)
           end

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

@@ -45,16 +45,24 @@ module RuboCop
             return if with_dependencies?(task_method)
 
             add_offense(task_method) do |corrector|
-              task_name = task_method.arguments[0]
-              task_dependency = correct_task_dependency(task_name)
-
-              corrector.replace(task_name, task_dependency)
+              if with_arguments?(task_method)
+                new_task_dependency = correct_task_arguments_dependency(task_method)
+                corrector.replace(task_arguments(task_method), new_task_dependency)
+              else
+                task_name = task_method.first_argument
+                new_task_dependency = correct_task_dependency(task_name)
+                corrector.replace(task_name, new_task_dependency)
+              end
             end
           end
         end
 
         private
 
+        def correct_task_arguments_dependency(task_method)
+          "#{task_arguments(task_method).source} => :environment"
+        end
+
         def correct_task_dependency(task_name)
           if task_name.sym_type?
             "#{task_name.source.delete(':|\'|"')}: :environment"
@@ -80,6 +88,14 @@ module RuboCop
           end
         end
 
+        def task_arguments(node)
+          node.arguments[1]
+        end
+
+        def with_arguments?(node)
+          node.arguments.size > 1 && node.arguments[1].array_type?
+        end
+
         def with_dependencies?(node)
           first_arg = node.arguments[0]
           return false unless first_arg

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

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Detect redundant `all` used as a receiver for Active Record query methods.
+      #
+      # @safety
+      #   This cop is unsafe for autocorrection if the receiver for `all` is not an Active Record object.
+      #
+      # @example
+      #   # bad
+      #   User.all.find(id)
+      #   User.all.order(:created_at)
+      #   users.all.where(id: ids)
+      #   user.articles.all.order(:created_at)
+      #
+      #   # good
+      #   User.find(id)
+      #   User.order(:created_at)
+      #   users.where(id: ids)
+      #   user.articles.order(:created_at)
+      #
+      # @example AllowedReceivers: ['ActionMailer::Preview', 'ActiveSupport::TimeZone'] (default)
+      #   # good
+      #   ActionMailer::Preview.all.first
+      #   ActiveSupport::TimeZone.all.first
+      class RedundantActiveRecordAllMethod < Base
+        include ActiveRecordHelper
+        include AllowedReceivers
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Redundant `all` detected.'
+
+        RESTRICT_ON_SEND = [:all].freeze
+
+        # Defined methods in `ActiveRecord::Querying::QUERYING_METHODS` on activerecord 7.0.5.
+        QUERYING_METHODS = %i[
+          and
+          annotate
+          any?
+          average
+          calculate
+          count
+          create_or_find_by
+          create_or_find_by!
+          create_with
+          delete_all
+          delete_by
+          destroy_all
+          destroy_by
+          distinct
+          eager_load
+          except
+          excluding
+          exists?
+          extending
+          extract_associated
+          fifth
+          fifth!
+          find
+          find_by
+          find_by!
+          find_each
+          find_in_batches
+          find_or_create_by
+          find_or_create_by!
+          find_or_initialize_by
+          find_sole_by
+          first
+          first!
+          first_or_create
+          first_or_create!
+          first_or_initialize
+          forty_two
+          forty_two!
+          fourth
+          fourth!
+          from
+          group
+          having
+          ids
+          in_batches
+          in_order_of
+          includes
+          invert_where
+          joins
+          last
+          last!
+          left_joins
+          left_outer_joins
+          limit
+          lock
+          many?
+          maximum
+          merge
+          minimum
+          none
+          none?
+          offset
+          one?
+          only
+          optimizer_hints
+          or
+          order
+          pick
+          pluck
+          preload
+          readonly
+          references
+          reorder
+          reselect
+          rewhere
+          second
+          second!
+          second_to_last
+          second_to_last!
+          select
+          sole
+          strict_loading
+          sum
+          take
+          take!
+          third
+          third!
+          third_to_last
+          third_to_last!
+          touch_all
+          unscope
+          update_all
+          where
+          without
+        ].to_set.freeze
+
+        POSSIBLE_ENUMERABLE_BLOCK_METHODS = %i[any? count find none? one? select sum].freeze
+
+        def_node_matcher :followed_by_query_method?, <<~PATTERN
+          (send (send _ :all) QUERYING_METHODS ...)
+        PATTERN
+
+        def on_send(node)
+          return if !followed_by_query_method?(node.parent) || possible_enumerable_block_method?(node)
+          return if node.receiver ? allowed_receiver?(node.receiver) : !inherit_active_record_base?(node)
+
+          range_of_all_method = offense_range(node)
+          add_offense(range_of_all_method) do |collector|
+            collector.remove(range_of_all_method)
+            collector.remove(node.parent.loc.dot)
+          end
+        end
+
+        private
+
+        def possible_enumerable_block_method?(node)
+          parent = node.parent
+          return false unless POSSIBLE_ENUMERABLE_BLOCK_METHODS.include?(parent.method_name)
+
+          parent.parent&.block_type? || parent.parent&.numblock_type? || parent.first_argument&.block_pass_type?
+        end
+
+        def offense_range(node)
+          range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end